OpenPylot
A Rust-powered personal AI assistant

OpenPylot is a modular, extensible personal AI assistant built in Rust. It ships as a single binary with a CLI, Web Dashboard, Python SDK, and Node.js SDK. Connect your calendar, email, social media, messaging apps, and documents — all backed by an encrypted secrets vault, pluggable LLM providers, a smart memory system, and autonomous sub-agents.

• Features
• What's New in v0.1.0
• Quick Start
• Usage — CLI
• Usage — Python SDK
• Usage — Node.js SDK
• Configuration
• Integrations
• Advanced Features
• Web Dashboard
• Background Service & Scheduler
• Docker
• API Reference
• Project Structure
• Development
• Troubleshooting
• Documentation
• License

Initial public release — highlights:

• 17 social media platforms — Facebook, Instagram, TikTok, YouTube, Pinterest, Reddit, Threads, Mastodon, Discord, Slack, Medium, Dev.to, Hashnode, WordPress (plus existing Twitter, LinkedIn, Bluesky)
• Smart Memory v2 — SQLite-backed semantic search with OpenAI embeddings, auto-extraction of personal facts
• Skills System — Declarative skills loaded from SKILL.md files, matched to user intents via embedding similarity
• Sub-Agent System — Spawn specialist agents with isolated context, delegated tool access, and configurable models
• MCP Support — Model Context Protocol integration for connecting external tool servers
• Learning Engine — LLM-as-judge auto-scoring (majority vote), prompt evolution, automatic SKILL.md generation from failure patterns
• Streaming Responses — Token-by-token streaming over WebSocket and SSE
• Marketing Agent — Campaign planning, content strategy generation, approval workflow
• Full config wiring — All platforms, MCP, learning, and marketing fully configurable via env / vault / TOML

# One-line installer (macOS / Linux)
curl -fsSL https://raw.githubusercontent.com/gmvofficial/OpenPylot/main/install.sh | bash

# Cargo (from crates.io)
cargo install openpylot

# Python
pip install openpylot

# Docker
docker compose up -d

# From source
cargo build --release && sudo cp target/release/pylot /usr/local/bin/

# Homebrew — coming soon
# brew tap gmvofficial/tap && brew install openpylot

# Node.js SDK — coming soon (not yet published to npm)
# npm install -g openpylot

Install methods available today: the one-line installer, cargo install openpylot, pip install openpylot, Docker, and building from source. Homebrew and the npm package are on the way.

pylot init          # Interactive setup wizard
pylot doctor        # Verify everything is configured
pylot               # Start interactive REPL

The init wizard guides you through:

1. LLM provider selection and API key
2. Agent name and persona
3. Integrations (Google Calendar & Gmail, Telegram, WhatsApp)
4. Notification preferences
5. Background scheduler configuration

All secrets are encrypted and stored in ~/.pylot/secrets.enc.

The native binary is the primary interface.

pylot

You> What meetings do I have today?
🔧 Calling tool: list_calendar_events
📅 Team Standup — 10:00 AM

Pylot: You have one meeting today — Team Standup at 10:00 AM.

You> Take a note: Review Q1 roadmap before the all-hands
🔧 Calling tool: create_note
✅ Note created.

You> /tools
Available tools: create_note, list_notes, search_notes, delete_note,
  list_calendar_events, create_calendar_event, create_meeting,
  gmail_search, gmail_get, gmail_send, gmail_reply,
  gmail_draft_create, gmail_draft_send, gmail_draft_delete,
  set_reminder, list_reminders, complete_reminder,
  send_telegram_message, get_telegram_updates, send_whatsapp_message,
  memory_store, memory_search, memory_list

pylot chat "Schedule a meeting with alice@example.com tomorrow at 2pm"

pip install openpylot

The Rust binary must also be on your PATH. The Python package wraps the native binary via PyO3.

from pylot import PylotAgent

agent = PylotAgent.from_config("~/.pylot/secrets.enc")
response = agent.chat("What meetings do I have today?")
print(response)

from pylot import PylotAgent, Config

config = Config(
    llm_provider="openai",
    llm_model="gpt-4o",
    openai_api_key="sk-...",
    telegram_bot_token="...",
)
agent = PylotAgent(config)
response = agent.chat("Schedule a meeting with John tomorrow at 3pm")
print(response)

def search_web(query: str) -> str:
    """Your custom tool implementation."""
    return "results..."

agent.register_tool(
    name="search_web",
    schema='{"type":"object","properties":{"query":{"type":"string"}}}',
    callback=search_web,
)

See python/README.md for full Python documentation.

⚠️ Coming soon — the Node.js SDK is not yet published to npm. You can build it from source in node/ in the meantime.

npm install openpylot   # coming soon

The Rust binary must also be on your PATH. The Node.js package wraps the native binary via NAPI-RS.

import { PylotAgent } from 'pylot';

const agent = await PylotAgent.fromConfig('~/.pylot/secrets.enc');
const response = await agent.chat('What meetings do I have today?');
console.log(response);

import { PylotAgent, Config } from 'pylot';

const config: Config = {
  llmProvider: 'anthropic',
  llmModel: 'claude-sonnet-4-20250514',
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
};

const agent = new PylotAgent(config);
const response = await agent.chat('Set a reminder for 5pm to review PRs');
console.log(response);

await PylotAgent.doctor();
await PylotAgent.status();

OpenPylot uses a layered configuration system (highest to lowest priority):

1. Environment variables
2. Encrypted secrets vault (~/.pylot/secrets.enc)
3. TOML config files (config/default.toml or ~/.pylot/config.toml)
4. Built-in defaults

See docs/CONFIGURATION.md for the full environment variable reference, TOML options, and secrets vault usage.

# config/default.toml
[agent]
name = "My Assistant"
persona = "You are a helpful personal assistant."

[llm]
provider = "openai"     # or "anthropic"
model = "gpt-4o"

[memory]
enabled = true

[social]
twitter_enabled = true
facebook_enabled = true

pylot add google-calendar

Requires OAuth 2.0 credentials from Google Cloud Console. See docs/INSTALLATION.md for step-by-step setup.

pylot add telegram
pylot telegram-bot     # Start bot mode

Create a bot via @BotFather. Bot commands: /start, /help, /tools, /clear.

pylot add whatsapp

Requires a Twilio account with WhatsApp sandbox or business number.

OpenPylot supports publishing, deleting, and analytics for 17 social media platforms. Each platform auto-enables when credentials are detected.

See docs/SOCIAL-PLATFORMS.md for detailed per-platform setup guides.

SQLite-backed semantic memory system with OpenAI embeddings:

• Personal memory — Auto-extracted facts from conversations ("User prefers morning meetings")
• Knowledge base — Upload documents, chunked and embedded for semantic search
• Configurable — Similarity threshold, chunk size, extraction interval

[memory]
enabled = true
embedding_model = "text-embedding-3-small"
auto_extract = true
similarity_threshold = 0.35

Declarative SKILL.md files with YAML frontmatter. Matched to user intents at runtime via embedding similarity and injected into the agent's context.

---
name: email-drafting
description: Draft professional emails
triggers:
  - draft an email
  - write an email
---

When drafting emails:

1. Ask for recipient, subject, and key points
2. Use a professional tone unless told otherwise
3. Keep paragraphs short

Spawn specialist sub-agents with isolated context and tool subsets:

• Researcher — Web search, document analysis
• Coder — Code generation, review
• Marketing — Campaign planning, content generation, social media publishing

Connect external tool servers via JSON-RPC:

[mcp]
enabled = true
# config_path = "~/.pylot/mcp-servers.json"

• Auto-scoring — LLM-as-judge rates response quality (configurable vote count, majority wins)
• Prompt evolution — Automatically adjusts system prompts based on feedback patterns
• Skill evolution — When success rate drops below 40%, auto-generates new SKILL.md files from failure analysis

[learning]
enabled = true
auto_score = false
judge_votes = 3
skill_evolution = false

A specialist sub-agent for social media automation:

• Create content strategies with target platforms and tone
• Generate platform-specific content drafts
• Review and approve content before publishing
• Track performance across platforms

OpenPylot ships with a Next.js web UI.

# 1. Start the backend API server (port 3001)
pylot serve

# 2. In another terminal, start the frontend (port 3000)
cd frontend && npm install && npm run dev

Open http://localhost:3000.

1. Navigate to Integrations (/setup)
2. Click Connect on a service
3. For Telegram / WhatsApp / GitHub / Slack: enter your tokens in the credential modal
4. For Google Calendar / Gmail: the backend starts an OAuth flow and opens the browser
5. Use Test to verify connectivity, Disconnect to remove credentials

Integrations configured via the CLI (pylot init or pylot add) are automatically visible in the web UI.

cd frontend && npm run build   # Generates static files in frontend/out/

# macOS (launchd)
pylot serve install

# Linux (systemd)
pylot serve install

pylot status            # Check status
pylot logs              # Tail agent logs
pylot jobs list         # List scheduled jobs
pylot jobs run <name>   # Run a job now
pylot serve uninstall   # Remove service

# Docker Compose (recommended)
docker compose up -d

# Or build manually
docker build -t pylot .
docker run --rm -it \
  -v ~/.pylot:/home/pylot/.pylot \
  -e OPENAI_API_KEY=sk-... \
  -p 3001:3001 \
  -p 8443:8443 \
  pylot

The backend API (default http://localhost:3001) exposes:

├── src/
│   ├── main.rs              # CLI entry point (clap)
│   ├── lib.rs               # Library crate (re-exports all modules)
│   ├── agent.rs             # Agent loop: LLM ↔ tool calls
│   ├── config.rs            # Layered config (env > vault > TOML > defaults)
│   ├── context.rs           # Conversation context management
│   ├── document_chunker.rs  # Document chunking for knowledge base
│   ├── memory.rs            # Persistent memory store (JSON)
│   ├── smart_memory.rs      # SQLite + embeddings semantic memory
│   ├── secrets.rs           # AES-256-GCM encrypted vault
│   ├── traits.rs            # Core traits
│   ├── init.rs              # Setup wizard, doctor, status
│   ├── terminal.rs          # Interactive REPL
│   ├── scheduler.rs         # Tokio cron scheduler
│   ├── oauth.rs             # Browser-based OAuth 2.0 flows
│   ├── telegram_bot.rs      # Telegram long-polling bot
│   ├── api/                 # Axum REST API + WebSocket handlers
│   ├── llm/                 # LLM provider trait + OpenAI, Anthropic
│   ├── tools/               # Tool registry + 8 built-in tools
│   ├── webhooks/            # Webhook endpoint handlers
│   ├── jobs/                # Background job definitions
│   ├── skills/              # Skill system (SKILL.md loader, matcher)
│   ├── memory_v2/           # Memory v2 (structured memory types)
│   ├── streaming/           # Token streaming (WebSocket, SSE)
│   ├── sub_agents/          # Sub-agent orchestration
│   ├── mcp/                 # Model Context Protocol client
│   ├── learning/            # Auto-scorer, prompt evolution, skill evolver
│   ├── social/              # Social media manager (17 providers)
│   └── marketing/           # Marketing agent (campaigns, content)
├── frontend/                # Next.js 15 web dashboard
├── python/                  # Python SDK (PyO3 + maturin)
├── node/                    # Node.js SDK (NAPI-RS)
├── config/default.toml      # Default TOML configuration
├── docs/                    # Documentation
├── plan_docs/               # Feature planning documents (00-13)
├── tests/                   # Test suites (Rust, Python, Node.js)
├── Formula/pylot.rb         # Homebrew formula
├── install.sh               # One-line installer
├── Dockerfile
├── docker-compose.yml
├── CONTRIBUTING.md
├── CHANGELOG.md
└── Cargo.toml

~/.pylot/
├── bin/pylot               # Binary (if installed via installer)
├── secrets.enc             # Encrypted secrets vault
├── config.toml             # User config overrides
└── data/
    ├── notes.json
    ├── reminders.json
    ├── memory.json
    ├── smart_memory.db     # SQLite semantic memory
    ├── google_tokens.json
    ├── gmail_tokens.json
    ├── knowledge_collections.json
    ├── knowledge_documents.json
    ├── history.txt
    └── conversations/

• Rust 1.75+ — rustup.rs
• Python 3.9+ and maturin — for Python bindings
• Node.js 18+ and @napi-rs/cli — for Node.js bindings

cargo build --release
cargo test                # 100 tests passing

cd python && maturin develop && pytest
cd node && npm run build && npm test

1. Create src/tools/your_tool.rs
2. Implement the Tool trait:

use async_trait::async_trait;
use serde_json::{json, Value};
use crate::tools::{Tool, ToolDefinition, ToolResult};

pub struct YourTool;

#[async_trait]
impl Tool for YourTool {
    fn definition(&self) -> ToolDefinition {
        ToolDefinition {
            name: "your_tool_action".into(),
            description: "What this tool does".into(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "input": { "type": "string", "description": "..." }
                },
                "required": ["input"]
            }),
        }
    }

    async fn execute(&self, params: Value) -> anyhow::Result<ToolResult> {
        let input = params["input"].as_str().unwrap_or_default();
        Ok(ToolResult::ok("Done!"))
    }
}

3. Register in src/main.rs

See CONTRIBUTING.md for development setup, commit conventions, and PR guidelines.

Run pylot doctor to diagnose issues automatically.

Full docs live in docs/. Highlights:

This project is licensed under the Apache License, Version 2.0. See the LICENSE file for full details.

Copyright 2026 Global Mind Ventures Ltd.