Feature List

As Cicero is still under development and nearing its initial release, this page is tailored for technical audiences. The foundation for all the features listed below has been laid, with significant progress made. With the Sophia NLU engine already operational, Quadris nearing completion, and Evolve soon to follow, the finalization of these features and Cicero's general release are in sight. While there is still work to be done, the end is within reach.

General

  • Cross-Platform Development: Built in Rust, Cicero offers cross-platform compatibility with simple binary installations, eliminating dependency issues and facilitating adoption by non-technical users.
  • LLM Integration: Utilizes the popular Ollama product for LLM integration, ensuring high-quality performance without reinventing the wheel.
  • Rust-Bert Integration: Integrates with the rust-bert and tch crates, with the C torch library statically included, though rust-bert may be removed in the future.
  • Easy Setup: On first run, Cicero detects a new installation and guides the user through a straightforward setup wizard.

Base Architecture

Cicero is designed to run on a home server, serving a multi-person residence where users connect from various devices. The repository includes three daemons, each compiled using Rust features to create different versions:

  • Apollo: The main application server handles all heavy lifting, inference, and user data storage. It serves a REST API over HTTPS.
  • Echo: Lightweight client that currently functions as a Progressive Web App (PWA), installed on the client machine and communicating with the Apollo server. It offers a web-based user panel personalized according to the user's preferences and installed plugins.
  • Helios: API endpoints deployed and authored by developers, with optional Cicero integration for inference and data. For full details, see the Helios page.

Most functionality within the Echo client involves communicating with Apollo via REST API with added encryption, making the development of additional clients, including mobile apps and wearables, straightforward.

Conversation

  • Echo includes the expected chat functionality, with searchable conversation history. Cicero uses Ollama for inference, leveraging their scrolling one-token-per-JSON-object API response format.
  • Input Processing:
    • Parsed by the Sophia NLU engine.
    • Scanned for new user information, which is sent to Quadris and committed to memory.
    • Scanned for verb/noun phrases or other criteria that trigger installed plugins (see below for details).
    • Context is gathered based on plugin triggers, if any.
    • Quadris is queried, including a nearest neighbor search against the FAISS index, to extract necessary memory as contextual information.
    • User input, along with context, is passed to the LLM router (see below) for a conversational reply.
  • Audio and video modalities will be managed via the Orion aspect of the project.

LLM Library / Router

  • Library Management: Cicero can manage a library of LLMs, allowing for interest-specific LLMs trained on specialized subjects (e.g., specific programming languages, advanced bioinformatics, ancient Egyptian hieroglyphics) to be downloaded and installed.
  • Automatic Routing: Each LLM has defined subject triggers, with a router automatically detecting the subject of user input and directing it to the appropriate LLM for a more personalized and in-depth response.
  • Searchable Library: Cicero’s hosting infrastructure provides users with a searchable library of interest-specific LLMs accessible from within their installation via the Echo client, akin to an app store.
  • Custom LLMs: Developers can train and upload interest-specific LLMs to Cicero's servers, making them available to others via the searchable library. Optionally, LLMs can be commercialized to recoup training costs.

Plugin Architecture

  • Extensible Architecture: Cicero’s plugin architecture offers limitless functional possibilities, with streamlined support for developers, including:
    • Trigger Definitions: Define verb/noun combinations that will trigger your plugin.
    • Conversation Pipelines: Engage with users through questions, confirmations, suggestions, and additional details.
    • API Objects: Access a wide range of API objects, including web scrapers, headless browsers, SSH clients, document writers (Microsoft Office and OpenOffice formats), embedded databases, communication suites, and more.
    • Sandboxed Execution: Easily set up and destroy sandboxed, virtualized Docker containers to execute code or establish specific environments.
    • Standard or Agentic Development: Utilize standardized development practices or leverage the custom Evolve model and novel agentic development methodologies for more fluid, dynamic, and personalized outcomes.
    • Plugin Integration: Import other plugins into your own, incorporating their existing tasks and functionality.
    • User Interface Customization: Add additional menus, pages, and functionality to the user-facing Echo client panels, allowing full interaction with the plugin as needed.
  • Developer-Friendly: Plugins are developed as Rust shared libraries. To get started, simply create a new crate and add the Cicero SDK as a dependency. Full details and step-by-step tutorials will be available upon release.
  • Plugin Distribution: Developers can publish plugins to Cicero’s servers, marking them as either open-source or commercialized to earn revenue. The plugin library will be accessible via the Echo client panels, organized in a categorized, browsable, and searchable format akin to modern app stores.

CFX (Cicero File Exchange)

  • Shared Directory: During Echo installation, a blank directory is created in the user’s home directory for sharing files with Cicero.
  • Persistent Connection: Upon starting the Echo client, an authenticated, encrypted, persistent TCP connection is established with Apollo.
  • File Transfer Commands: The connection supports standard file transfer commands (list, send, receive files), enabling file sharing between the user and Cicero without intrusive access to the user's local machine.
  • No Remote Mounting: Directories are not remotely mounted to avoid complications; instead, a basic TCP protocol similar to FTP is used.

Security

  • Encrypted Communication: All communication between the client and server occurs over TLS, with dynamic TLS certificates generated during installation and shared during client setup.
  • Data Encryption: All user data is encrypted using AES-GCM, with x25519 for key exchange.
  • In-Memory Data Handling: Unencrypted data is never written to disk, residing only in memory while the user is logged in.
  • Data Segregation: User data is segregated with separate key pairs for x25519, ensuring the server owner has no access to user data. Parental controls can be added if necessary.
  • Envelope Encryption: Envelope encryption is employed using a 32-byte encryption key, a 12-byte IV, with HKDF for child key derivation, and a 32-byte nonce, combined with Argon2 for outer seal password hashing.

User Profiles

  • Mandatory Information: The only mandatory information for each user profile is a randomly generated 16-byte UUID, along with a desired username and password.
  • Optional Information: Users can specify a nickname for Cicero to use and provide an email address for notifications.
  • First User Setup: During initial installation, the first user is automatically created. Subsequent users require an invitation code generated by the first user/administrator during Echo setup to register on the Apollo server.
  • Secure Storage: Each user has a secure profile, encrypted via AES-GCM, with unencrypted data never written to disk. Sensitive data such as credentials, API keys, and SSH keys can be securely stored.
  • Personalized Introduction: During the first chat after account setup, Cicero will engage in a conversation to learn about the user, their interests, hobbies, and how it can assist them. This information is committed to memory via Quadris to provide personalized assistance.

Stay Informed

Development is nearing completion, with Evolve being the final component before the Cicero general release. Enter your email below to receive updates and release notifications.