Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/dallay/corvus/llms.txt

Use this file to discover all available pages before exploring further.

​
Introduction to Corvus

Corvus is a reactive, always-on agent platform designed for long-running orchestration workloads. Built with a robust Kotlin Multiplatform foundation and powered by a high-performance Rust runtime, Corvus provides a secure, sandboxed environment for AI agents to perform complex, multi-step tasks.
Fast, small, and fully autonomous - Corvus delivers a ~3.4MB binary with <10ms startup time, 1,017 tests, 22+ AI providers, and 8 core traits for maximum extensibility.

​
What is Corvus?

Corvus is a highly extensible, multi-interface agentic platform that bridges the gap between AI autonomy and human supervision. It’s designed for teams who need:
  • Ultra-lightweight deployment: <5MB memory footprint - 99% smaller than comparable frameworks
  • Minimal infrastructure costs: Efficient enough to run on $10 hardware
  • Lightning-fast startup: 400X faster startup time, boots in <10ms
  • True portability: Single self-contained binary across ARM, x86, and RISC-V

​
Key Features

Multi-Interface Support

Interact with Corvus via CLI, Compose Multiplatform Desktop app, or web-based dashboard

Always-On Autonomy

Daemon mode for long-running agents that handle background tasks and persistent orchestration

Secure Sandboxing

Execute dangerous commands safely within isolated Docker containers or restricted native runtimes

Standardized Identity

Support for AIEOS v1.1, allowing portable and model-agnostic AI personas

Hybrid Memory Model

Pluggable memory backends including SQLite, Neo4j, and SurrealDB for high-context retrieval

Rich Integrations

First-class support for WhatsApp, Telegram, Discord, Slack, and messaging platforms

​
Why Teams Choose Corvus

​
Lean by Default

Corvus is built with Rust for maximum efficiency:
  • Small binary size (3.4MB)
  • Fast startup (<10ms on modern hardware)
  • Low memory footprint (<5MB)
  • Minimal resource consumption

​
Secure by Design

Security is enforced at every layer:
  • Gateway pairing with one-time codes
  • Strict sandboxing with Docker or native isolation
  • Explicit allowlists for all integrations
  • Workspace scoping to prevent filesystem escapes
  • Encrypted secret storage

​
Fully Swappable Architecture

Every core system is built on traits for maximum flexibility:
  • Providers: 22+ AI model providers (OpenRouter, Anthropic, OpenAI, Ollama, etc.)
  • Channels: CLI, Telegram, Discord, Slack, iMessage, Matrix, WhatsApp, Webhook
  • Memory: SQLite, SurrealDB, Markdown
  • Tools: shell, file operations, memory, browser automation
  • Runtime: Native or Docker sandboxed execution

​
No Lock-In

Corvus supports OpenAI-compatible provider APIs plus custom endpoints, ensuring you’re never locked into a single vendor.

​
Architecture Highlights

Corvus Architecture Corvus follows a trait-based architecture where every subsystem is swappable:
SubsystemTraitWhat’s Included
AI ModelsProvider22+ providers including OpenRouter, Anthropic, OpenAI, Ollama, Venice, Groq, Mistral, xAI, DeepSeek, Together, Fireworks, Perplexity, Cohere, Bedrock
ChannelsChannelCLI, Telegram, Discord, Slack, iMessage, Matrix, WhatsApp, Webhook
MemoryMemorySQLite (hybrid search), SurrealDB, Markdown
ToolsToolshell, file_read, file_write, memory operations, browser_open
RuntimeRuntimeAdapterNative, Docker (sandboxed)
SecuritySecurityPolicyGateway pairing, sandbox, allowlists, rate limits, filesystem scoping

​
Technology Stack

Kotlin Multiplatform

Core logic shared across Desktop, Android, iOS, and Web

Rust Agent Runtime

High-performance sidecars and CLI (clients/agent-runtime/)

Compose Multiplatform

Cross-platform desktop and mobile UI

Astro + Vue 3

Modern web stack with Tailwind CSS

​
Performance Comparison

Benchmark snapshot comparing Corvus to similar frameworks (normalized for 0.8GHz edge hardware):
MetricOpenClawNanoBotPicoClawCorvus
LanguageTypeScriptPythonGoRust
RAM>1GB>100MB<10MB<5MB
Startup (0.8GHz)>500s>30s<1s<10ms
Binary Size~28MBN/A~8MB3.4MB
CostMac Mini $599Linux SBC ~$50Linux Board $10Any hardware $10
Corvus results measured with /usr/bin/time -l on release builds. Reproduce locally:
cargo build --release
/usr/bin/time -l target/release/corvus --help

​
Getting Started

Ready to start building with Corvus? Check out these resources:

Quickstart

Get your first agent running in under 5 minutes

Installation

Install Corvus via npm, cargo, or binary download

Development

Learn how to develop and extend Corvus

API Reference

Explore the complete API documentation

​
Project Structure

Corvus is organized as a monorepo: 
corvus/
├── clients/
│   ├── agent-runtime/    # High-performance Rust Agent Core & CLI
│   ├── composeApp/       # Shared UI logic for Desktop/Mobile
│   ├── web/              # Web monorepo (Docs, Dashboard, Marketing)
│   ├── androidApp/       # Android specific wrapper
│   └── iosApp/           # iOS specific wrapper
├── modules/
│   └── agent-core-kmp/   # Core Kotlin Multiplatform logic & contracts
├── dev/                  # Local development environment (Docker/Sandbox)
├── gradle/               # Build logic and configurations
└── Makefile              # Standard entry point for development tasks

​
License

Corvus is licensed under the Apache License 2.0.
Active Development: Corvus is currently in active development. Features and architecture are subject to evolution.

Build docs developers (and LLMs) love

Get started for freeTalk to us