Integration & Communication Layer

&milo’s architecture is designed for seamless extensibility, enabling effortless integration of new functionalities, tools, and communication channels.

The Integration & Communication Layer acts as the bridge between agents, external systems, and users, ensuring smooth interactions across different platforms. This layer is built with a modular, pluggable framework, allowing easy customization and expansion.

Framework Pluggability

At its core, &milo’s system is built with modular extensibility, making it easy to enhance functionality without disrupting the existing architecture. New capabilities, models, or tools can be integrated through well-defined interfaces, ensuring that developers can extend the system without modifying the core agentic infrastructure and at Ease.

1. Pluggable Tools & Functions

• Each agent operates with a defined toolset that can be expanded or customized.

• New tools can be registered and assigned to specific states within an agent’s state graph.

• Custom actions, APIs, or third-party services can be added via a tool registration system.

2. Adding New Functionalities

• Agents are designed to be task-specific, meaning new functionalities can be introduced as independent agents rather than modifying existing ones.

• Developers can add agent capabilities by defining new state graphs, tools, and decision workflows.

• Agents can dynamically inherit system memory and preferences, ensuring smooth interaction with the rest of the framework.

Extending the Communication Layer

Communication is central to the &milo system. Chat is the base communication layer, always present within the system, providing an interface for agent interaction, user queries, and execution requests. However, additional communication channels can be plugged into the framework as needed.

1. Native &milo Chat

The built-in chat communication system in the &milo framework offers developers the flexibility to choose its utilization. This system is fully equipped to support both chat streams and sockets, providing robust solutions for dynamic communication needs.

2. Implementing New Communication Layers

To extend the communication capabilities of the &milo system, developers can implement new communication layers by adhering to the following interface:

export interface ICommunicationLayer {
  sendMessageToUser(
    tenantIdentity: TenantIdentity,
    conversation: IConversation,
    data: Pick<
      IConversationMessage,
      'messages' | 'metadata' | 'userId' | 'channel' | 'conversationId'
    >,
  ): Promise<boolean>;
}

Implementing this interface ensures that the new communication layer is compatible with the system and can be registered and discovered by the agent framework. This allows for seamless integration of various messaging platforms into the &milo ecosystem.

// Has to Register to be discoverable by the Agent framework
communicationsManager.registerCommunicationService(ChannelType.DIRECT_CHAT, this);

3. Built in Tools

In the &milo system, a variety of built-in tools are available to facilitate different operations. Some of these include:

• FetchTransaction: A tool to retrieve transaction data by accessing the transaction from the network RPC.

• ScanProgram: This tool allows for the scanning and analysis of specific programs to ensure integrity and compliance.

• Swap: Enables users to swap tokens from known liquidity pools providers.

• Transfer: Facilitates the transfer of funds or tokens between wallets.

4. Adding new capabilities

&milo’s architecture is designed with extensibility at its core, ensuring that new capabilities can be integrated effortlessly to accommodate system-specific needs. Every system has unique requirements, and providing a structured way to expose system-specific interactions is fundamental to our approach. Tools serve as the primary method for extending agent functionality, allowing developers to integrate new actions, API calls, or computational logic without altering the system’s core architecture.

New tools must adhere to a strict interface to ensure consistency, security, and interoperability across the agentic system. Each tool is represented as a FunctionDetail object, which defines its name, purpose, parameters, and execution behavior. Developers register tools within an agent’s manifest, which dictates how and when they can be used within different agent states.

export abstract class FunctionDetail {
  // Tool Definition
  name: string;
  description: string;
  parameters: JSONSchema;
  embeddingSearchDescription?: string;
  type: 'tool' | 'skill' = 'tool';

  // Runtime Execution Details
  tenantIdentity: TenantIdentity;
  reasonModel: GenericLLM;
  executionModel: GenericLLM;
  embeddingModel: string;
  sendUserActionUpdate: (update: string) => void;
  recipientRole: 'member' | 'external';

  constructor(
    name: string,
    description: string,
    parameters: JSONSchema,
    tenantIdentity: TenantIdentity,
    reasonModel: GenericLLM,
    executionModel: GenericLLM,
    embeddingModel: string,
    sendUserActionUpdate: (update: string) => void,
    recipientRole: 'member' | 'external',
    embeddingSearchDescription?: string,
    type?: 'tool' | 'skill'
  )
  // Unified Execution Interface
  abstract call(
    parameters: unknown,
    context?: { [key: string]: any },
  ): Promise<toolResult>;
}

Security and Governance

&milo’s tool system operates under strict tenancy and execution guardrails, ensuring that tools are secure, role-aware, and governed by access policies.

• Tenancy Management – Tools are assigned to specific tenants, ensuring isolation between different users or organizations.

• Recipient Role Enforcement – Tools define recipient roles (member vs. admin), ensuring that actions are appropriately managed.