AI Scientist-v2: Modular AI Discovery

• AI Scientist-v2 Systems are advanced architectures for automated scientific discovery that integrate modular AI components with standardized interfaces and flexible orchestration for building cyclic and hybrid workflows.
• They employ containerized modules via Docker and gRPC/Protobuf, leveraging asynchronous, event-driven orchestration to enable dynamic control, user interface integration, and efficient shared storage.
• The system supports reproducible, scalable deployments on Kubernetes and encourages community-driven enhancements through its open-source, Eclipse Graphene foundation.

AI Scientist-v2 Systems are advanced architectures for automated scientific discovery that integrate modular AI components, standardized interfaces, and a flexible orchestration layer. Evolving from earlier frameworks such as Acumos, these systems support composition of heterogeneous, containerized AI modules—including both data-driven and knowledge-based systems—across complex, cyclic, and hybrid interaction patterns. Central attributes of AI Scientist-v2 Systems include graph-based solution assembly, event-driven orchestration, support for user interfaces and shared storage, and streamlined deployment, all governed by open-source principles to foster community-driven extensibility and reproducibility.

1. Architectural Foundations and Component Integration

AI Scientist-v2 builds on a containerized architecture where each AI component (e.g., a classical ML predictor, logical reasoner, or custom service) is encapsulated as a Docker container exposing a gRPC service on a fixed port (8061 for core RPC, 8062 optionally for a web UI) (Schüller et al., 2022). Every component implements Protobuf-based RPC interfaces with one-to-one input/output message types, supporting both static and streaming RPCs. This standardization enables arbitrary reuse and replacement of components, mirroring the impact of OpenCV and ROS in their respective domains.

A key architectural innovation is the strict separation of component logic from the orchestration “glue.” The orchestrator, a centralized manager, mediates all inter-component communication: it routes RPC calls (synchronously and asynchronously), coordinates event-based triggers, and manages message flows in topologically arbitrary (including cyclic and branching) solution graphs. This allows for complex topologies such as feed-back control loops, sub-component hierarchies, and event-driven branches.

A schematic can be represented as: $$\begin{array}{c} \text{[Container A]} \overset{\text{RPC calls}}{\longleftrightarrow} \text{Orchestrator} \overset{\text{RPC calls}}{\longleftrightarrow} \text{[Container B]} \ \text{(gRPC: port 8061)} \end{array}$$

This flexible, standardized connectivity is essential for assembling modular, domain-general AI pipelines.

2. Orchestration, Control Flow, and Execution Paradigms

The orchestration layer employs a multi-threaded model to manage control flow. Unlike traditional dataflow engines enforcing an acyclic order (as in the original Acumos), the AI Scientist-v2 orchestrator enables asynchronous, event-driven execution. Streaming RPCs let components emit events or data flows consumed by dependent modules. The orchestrator records all event logs (including the message routing trace), providing diagnostics and opens up possibilities for runtime introspection and debugging.

This event-based orchestration enables practical AI system patterns:

• Control Loops: For tasks such as robotics, a sensor-processing-actuator-action loop is assembled as a cycle, where each component's output triggers subsequent inputs in closed loop.
• Sub-component Reuse: One module may act as both a standalone service and as a subroutine invoked by other components.
• Event-Driven Interaction: A UI-component may listen for updates and asynchronously send user events to processing backends and receive real-time visualizations or evaluation responses.

The orchestrator manages synchronization and parallelism, handling both synchronous calls and streaming, potentially supporting load-adaptive scaling when deployed under Kubernetes.

3. User Interface Integration and Shared Storage Mechanisms

AI Scientist-v2 introduces direct support for human-in-the-loop components and efficient data sharing:

• GUI Integration: Each component can expose an auxiliary web service (on port 8062), allowing user interfaces for interactive input, real-time display, or operator feedback. In the Sudoku Design Assistant example, a GUI streams evaluation requests and receives updates using distinct RPC methods for event communication, coupled with a backend solver orchestrated in the graph.
• Shared Filesystem Component: For high-throughput or large-volume data transfer, a shared filesystem module is provided as a separate container, enabling any data-intensive component to read/write to a common storage area by explicit graph linkage rather than by transmitting bulky blobs over gRPC.

This dual-mode interface (gRPC and HTTP/Web) and the explicit shared-storage abstraction lower the friction of building hybrid, interactive, and data-intensive scientific applications.

4. Deployment, Portability, and Example Applications

Deployment workflows are automated: an entire solution consisting of containers and orchestration logic can be bundled into a ZIP and deployed to a Kubernetes cluster using supplied scripts that require only minimal configuration (e.g., namespace specification).

Illustrative applications in the system include:

• Sudoku Tutorial: Integrating a GUI, design evaluator, and Answer Set Solver via defined Protobuf RPCs, illustrating the full stack from user-facing interface to solver logic in a hybrid graph.
• Maze Planner: Demonstrates complex event-driven control loops with planning, execution, simulation, and visualization tightly orchestrated, including multiple feedback and error-reporting cycles.
• Computer Vision Case: Real-time object detection and visualization using a YOLO-based detector, camera interface, and a “collator” to join visual data with object information for display.

The system’s design supports both low-latency, interactive tasks (control systems, GUI-driven analytics) and compute/data-intensive experimentation.

5. Open Source Foundation and Community Ecosystem

The platform is open sourced as “Eclipse Graphene,” managed under the Eclipse foundation and accessible at aiexp.ai4europe.eu (Schüller et al., 2022). All software—including the platform, orchestrator, component specifications, and component catalog—is maintained for unrestricted academic and industrial development. This open-source orientation is critical for reproducibility, collaborative library growth, ongoing improvement, and avoidance of vendor lock-in.

A distributed developer community can contribute new components (with standardized gRPC/Protobuf interfaces), expand catalogs, share best practices, and run solutions in private or cloud clusters. This environment accelerates innovation in assembling hybrid AI workflows that crosscut domains and methodologies.

Platform Feature	Mechanism	Impact
Modular Container Integration	Docker + gRPC/Protobuf	Portability; Interoperability
Orchestration	Event-driven, multi-threaded orchestrator	Complex topologies; Cyclic workflows
User Interface	Optional webserver (port 8062) in Docker	Real-time human-in-the-loop
Shared Storage	Shared Filesystem container	Efficient data flow for large files
Deployment	Scripted ZIP packaging; Kubernetes	Automated, scalable deployments
Open Source	Eclipse Graphene on aiexp.ai4europe.eu	Community-driven extensibility

6. Significance and Implications

AI Scientist-v2 (AI4EU Experiments Platform) represents a shift from rigid, linear ML pipeline systems toward flexible, agentic AI orchestration environments capable of integrating heterogeneous, reusable modules into branching, cyclic, and mixed-interaction graphs. By combining standardized module interfaces, centralized event-driven orchestration, explicit user interaction endpoints, and scalable data sharing, the framework enables rapid prototyping and deployment of sophisticated scientific workflows.

This architecture is directly applicable to diverse domains—autonomous robotics, real-time vision, reasoning-driven analytics, multi-modal UI, and more—and accelerates experimentation and translation of new AI methodologies into practical, reproducible pipelines.

Its commitment to open-source operation and extensibility positions the system as an enabling substrate for the broader AI research community, fostering experimentation, component sharing, and deployment of hybrid, interactive, and collaborative AI-driven scientific solutions at scale.