AionUi

AionUi implements a protocol-agnostic agent abstraction layer that bridges multiple AI agent standards (ACP, Codex, OpenClaw, Gemini CLI) through a common message transformation pipeline. The system uses event-driven communication with a message transformation pipeline that normalizes inputs from heterogeneous agent protocols into a unified conversation data model, then routes outputs back to the appropriate protocol handler. This enables seamless switching between agents without UI changes.

AionUi uses Electron's multi-process architecture to isolate high-privilege system operations (Main process) from the UI renderer and AI orchestration tasks. The Main process handles file system access, native module loading, and system-level tool execution, while the Renderer process manages UI state and the WebUI server handles remote agent communication. Inter-process communication (IPC) uses a request-response pattern with explicit permission gates for sensitive operations.

AionUi implements a message rendering system that displays agent responses in real-time as they stream from the model, with support for markdown formatting, code syntax highlighting, and interactive UI elements (buttons, forms). The renderer uses a virtual scrolling approach to handle large conversation histories efficiently, with lazy loading of older messages from the database. Streaming responses are buffered and rendered incrementally, with a visual indicator showing when the agent is still generating content.

AionUi implements a channel architecture that routes conversations to different platforms (desktop UI, WebUI, mobile app, CLI) while maintaining unified conversation state. Each channel has a platform-specific message adapter that translates between the unified conversation data model and platform-specific formats. Channels can be enabled/disabled per-conversation, allowing users to choose which platforms can access a conversation.

AionUi provides an extension system that allows third-party developers to add new agents, tools, and UI components without modifying the core application. Extensions are defined via a manifest file that declares their capabilities, required permissions, and lifecycle hooks. The extension sandbox enforces permission scoping (e.g., an extension can access files only in a specific directory) and provides a stable API for accessing core functionality. Extensions are loaded at startup and can be enabled/disabled per-user.

AionUi implements a conversation initialization system that prepares agents for a new conversation by injecting context (workspace files, recent history, user preferences) and priming their memory with relevant information. The system uses a context builder that collects relevant files, previous conversation summaries, and user-defined context, then passes this to the agent as part of the initial system prompt. Context injection is configurable per-conversation, allowing users to control what information agents see.

AionUi uses a unified conversation data model that normalizes messages from heterogeneous agent protocols into a common format, with a message transformation pipeline that handles serialization, deserialization, and protocol-specific metadata preservation. The data model tracks message provenance (which agent/user produced it), tool invocations, and file modifications, enabling rich conversation analysis and replay. The transformation pipeline is extensible, allowing new protocols to be added without modifying the core data model.

AionUi bundles native implementations of the Gemini agent and aionrs (a Rust-based agent runtime) directly into the application, eliminating the need for external CLI tools or separate agent installations. The Gemini agent uses Google's native SDK with full file access and tool scheduling capabilities, while aionrs provides a lightweight, compiled agent runtime. Both are initialized during application startup and managed through a unified agent lifecycle manager that handles model configuration, API key rotation, and tool registry updates.

AionUi provides a centralized model configuration system that manages API keys, model selection, and provider credentials for multiple AI backends (OpenAI, Anthropic, Google, etc.). The system implements secure API key rotation with automatic fallback to backup keys, encrypted storage in the local database, and per-conversation model override capabilities. Configuration changes are persisted to the database and broadcast to all agent instances via event-driven updates.

AionUi implements a cron scheduler that allows agents to execute tasks on a recurring schedule without user interaction, enabling true 24/7 automation workflows. The scheduler stores cron expressions in the database, evaluates them at runtime, and triggers agent execution with pre-configured prompts and tool access. Scheduled tasks run in the background without blocking the UI, with execution logs persisted to the database for audit and debugging.

AionUi runs an Express-based WebUI server that exposes agent capabilities via HTTP/WebSocket APIs, enabling remote access from mobile apps, browsers, and other clients. The server implements WebSocket bridging that maintains persistent connections to remote clients, synchronizes conversation state in real-time, and proxies tool execution requests back to the local agent runtime. Authentication uses API tokens stored in the database, with per-token permission scoping for multi-user scenarios.

AionUi integrates the Model Context Protocol (MCP) as a standardized tool interface, allowing agents to invoke tools defined via MCP schemas without hardcoding tool logic. The system implements native bindings for common MCP tools (file operations, web search, code execution) and a plugin registry that dynamically loads external MCP tools at runtime. Tool invocations are routed through a unified tool executor that handles error recovery, timeout management, and result serialization.

AionUi allows users to create and save assistant presets that bundle model selection, system prompts, tool configurations, and skill definitions into reusable profiles. Presets are stored in the database and can be applied per-conversation, with conversation-scoped overrides that don't affect the preset definition. Skills are modular prompt templates that agents can invoke to perform specific tasks (e.g., 'code-review', 'documentation-generation'), with skill parameters that can be customized per invocation.

AionUi implements a team mode that allows multiple agents (or multiple instances of the same agent) to collaborate on a single conversation, with shared context and coordinated tool execution. The system uses a conversation data model that tracks which agent produced each message, implements conflict resolution for concurrent tool writes, and provides a UI for monitoring and controlling agent interactions. Team mode requires explicit permission gates for sensitive operations and audit logging of all agent actions.

AionUi provides a file and workspace management system that allows agents to read and write files within designated workspace directories, with access control enforced at the IPC layer. The system implements path normalization to prevent directory traversal attacks, file locking to prevent concurrent writes, and a file change watcher that notifies agents of external modifications. Workspace configuration is stored per-conversation, allowing different conversations to operate on different file sets.