Agent–SMO/RIC Integration

A stable, long-term pattern for generated agents within the NeuAIs platform.

Overview

Our orchestration model has followed the same shape since early platform development: SMO (System Management & Orchestration) coordinates agent lifecycle and event routing, and RIC (Resource Information Coordinator) provides shared ML inference and metrics services.

All production rApps have used this pattern for several years. Generated agents now adopt these same conventions. This brings the scaffolding layer into alignment with the existing runtime model and removes the need for manual wiring during prototyping and early development.

The goal of this work is not to introduce a new capability, but to ensure that every generated agent behaves consistently with the agents already operating in the core platform.

Platform Context

Inside NeuAIs, agents are designed as independent, routable functions that rely on the platform rather than bespoke glue code. Standardisation around SMO and RIC has ensured:

• predictable lifecycle management
• consistent health/status interfaces
• a uniform event contract
• access to shared ML capabilities
• compatibility with our deployment and observability tooling

By updating the generator templates, newly created agents now inherit the same stability and operational guarantees as long-running rApps.

Behavioural Contract for Generated Agents

All generated agents—regardless of language or workload type—conform to the platform’s established rApp interface:

1. Startup Registration

On boot, an agent registers with SMO. Registration includes metadata, capability name, and expected event types. This is the same handshake used by all production agents.

2. Standard Endpoints

The agent exposes a small, stable HTTP interface:

• /health — readiness/liveness
• /status — internal state summary
• /metadata — static capability + config
• /event — event processing entry point

These endpoints mirror the existing rApp contract.

3. RIC Client Integration

Agents can call RIC for ML inference or metrics updates. The integration is minimal and follows the platform’s standard client behaviour.

4. Lifecycle Hooks

Every agent implements initialise/start/stop behaviours that SMO can rely on for orchestration and graceful shutdown.

Template Implementation

The generator produces templates that include the platform contract:

Rust-based Agents

• Implement the Agent trait from the internal agent framework
• Adapted to rApp conventions via the AgentRAppAdapter
• Expose standard endpoints through Axum
• Include a lightweight RIC HTTP client

Go-based Agents

• Extend the BaseRApp type from the ai-network module
• Provide the standard lifecycle functions
• Include idiomatic RIC and SMO clients
• Provide the same endpoint surface as the Rust agents

Although implementation differs per language, the contract is uniform and stable.

Configuration

Generated agents use the same environment variables as production agents:

These defaults remain consistent across environments to simplify deployment and local development.

Operational Model

With this integration, generated agents immediately participate in the standard runtime flow:

SMO → Agent → RIC → Agent → SMO

• SMO discovers and manages agents
• Agents process events through /event
• RIC provides inference/metrics when requested
• SMO uses responses to continue orchestration

No custom integration or manual wiring is required.

Deployment Pattern

Generated agents follow the same containerisation and deployment pattern as all platform services:

• multi-stage Dockerfiles for small images
• environment-driven configuration
• compatibility with Docker Compose and Kubernetes
• identical logging and health-check behaviour

This ensures any environment that can run a production rApp can also run a newly generated agent.

Verification Practices

The generator emits agents that should compile and run immediately within their language toolchain. Teams integrating new agents can rely on these checks:

• Registration: confirm SMO logs show the agent handshake
• Health: verify /health and /metadata return expected structures
• Event Flow: send a test event and confirm RIC calls occur when required
• Deployment: container should build and run with platform defaults

These checks reflect the same verification steps used for long-standing agents.

Known Considerations

Some generated agents may require version alignment with the platform-pinned toolchains (e.g., Rust crate versions). These cases are environmental rather than architectural and do not affect the underlying rApp contract.

Summary

Bringing the generator templates in line with the established SMO/RIC model ensures that:

• developers work with a consistent mental model
• generated agents behave identically to mature rApps
• no bespoke integration is needed during early development
• platform behaviour is uniform across all languages and workloads

This update strengthens the continuity of the NeuAIs platform and reinforces the reliability of agent behaviour across environments.