Cerebro

Ship like a 50-person team — solo.
The open-source AI studio for solopreneurs and small teams. Build a roster of expert agents that research, draft, automate, and follow through as a team — and get a workweek back, every week.

Why Cerebro?

Solopreneurs and small teams are running ten roles at once — research, drafting, ops, customer follow-up, content, code. Most AI tools give you one chat window that forgets everything between sessions. Cerebro gives you a studio of specialized experts — each with persistent memory, tool access, and the ability to plan and execute multi-step work as a coordinated team.

Built for

• Solopreneurs running multiple products, clients, or income streams at once.
• Two-to-five-person teams that want a force-multiplier without hiring.
• Indie hackers, agency operators, and consultants who'd rather brief an expert than copy-paste between five tabs.
• Operators who want their work data on their own machine — conversations, memory, and routines live in local SQLite. MIT-licensed. Yours to fork.

Features

Specialized AI Agents

Create domain-specific experts — Research Analyst, Content Writer, Sales Ops, Customer Success, Bookkeeper — each with their own memory, model selection, and tool access. Select an expert in the chat tray, or let Cerebro route automatically. Need a new specialist? Describe it in plain English and Cerebro will vibe-engineer one for you: propose, preview, install.

Multi-Agent Orchestration

Compose teams of agents with a coordinator, role-based delegation, and sequential or parallel execution strategies. Example: a "Meeting Ops" team where Researcher pulls context, Analyst extracts action items, Writer drafts follow-ups, and Reviewer checks tone — all in one coordinated run.

Workflow Automation from Chat

When Cerebro detects repeatable work, it proposes saving it as a reusable routine — a directed graph of steps compiled from plain English. Preview runs through the real execution engine with live streaming logs. Trigger routines on a cron schedule, via webhook, or manually.

Autonomous Tasks

Give Cerebro a goal — a spec, an app, a research brief — and it will decompose it into phases, assign experts, execute each step, and deliver the result. Tasks support clarification questions before execution, live console output, workspace file browsing, and a final deliverable view.

Trust by Design

Approval gates pause execution before sensitive actions (sending emails, editing calendars). Every run streams live logs to the UI and writes a complete record to Activity. Drill into any run to see step-by-step execution, timestamps, inputs, outputs, and errors.

Long-Term Memory

Three-tier scoped memory that grows with you: context files (your profile, communication style, project notes), learned facts (auto-extracted from conversations), and knowledge entries (structured domain records like customer conversations, deals, content calendar, weekly metrics). Memory is scoped per user, per expert, and per routine — fully viewable and editable in Settings.

Voice Interface

Voice call mode with any expert. Local speech-to-text via faster-whisper and text-to-speech via Kokoro ONNX — no cloud transcription required. Waveform visualization, live transcript, and subtitles built in.

Remote Chat via Telegram

Chat with Cerebro from your phone over Telegram. No public URL or tunnel needed — Cerebro long-polls the Telegram Bot API from your laptop. Bring your own bot token (nothing hard-coded in the repo), allowlist your Telegram user IDs, and you get streamed replies, voice-note transcription via the local Whisper model, inline approval buttons, and routines that DM you on completion. See docs/telegram.md for the full setup guide.

Architecture

Electron Main Process
├── React 19 + Tailwind CSS 4 (renderer)
├── Agent Runtime (pi-agent-core)
├── Execution Engine (DAG executor)
├── Routine Scheduler (node-cron)
├── Voice Session Manager
├── Sandbox Environment
│
└── Python / FastAPI Backend (child process)
    ├── SQLAlchemy + SQLite
    ├── Memory System (context, facts, knowledge)
    ├── Experts / Skills / Routines
    ├── Voice Engines (STT / TTS)
    └── Sandbox Enforcement

Getting Started

Prerequisites

• Node.js >= 20
• Python >= 3.11
• Git
• (macOS) Xcode Command Line Tools — required for native modules (node-pty)

Installation

# Clone the repository
git clone https://github.com/AgenticFirst/Cerebro.git
cd Cerebro

# Set up the Python backend
cd backend
python3 -m venv venv
source venv/bin/activate   # Windows: venv\Scripts\activate
pip install -r requirements.txt
cd ..

# Install frontend dependencies
# (postinstall automatically downloads voice models ~340 MB)
npm install

# Start the app
npm start

On first launch, the app will guide you through setup. Once you're in, head to Experts to spin up your first specialist — or just start chatting with Cerebro to delegate.

Development

Project Structure

Cerebro/
├── src/                  # Electron + React frontend
│   ├── agents/           # Agent runtime & tool definitions
│   ├── components/       # React UI (screens, chat, layout, experts)
│   ├── context/          # React context providers
│   ├── engine/           # DAG execution engine
│   ├── i18n/             # Internationalization (en, es)
│   ├── sandbox/          # Sandbox enforcement
│   ├── scheduler/        # Cron scheduler
│   └── voice/            # Voice session management
├── backend/              # Python FastAPI server
│   ├── experts/          # Expert CRUD
│   ├── memory/           # Memory system
│   ├── routines/         # Routine CRUD & execution
│   ├── engine/           # Backend execution engine
│   ├── skills/           # Skills system
│   ├── voice/            # STT / TTS engines
│   └── tests/            # Pytest suite
├── docs/                 # PRD, tech designs, architecture
├── scripts/              # Setup & voice model download
└── assets/               # App icons

Commands

# Run all tests
npm test

# Frontend tests only
npm run test:frontend

# Backend tests only
npm run test:backend

# Lint
npm run lint

# Format
npm run format

# Package for current platform
npm run package

# Create distributable (DMG, EXE, DEB, RPM)
npm run make

Roadmap

See the full roadmap for details.

• App shell + chat with streaming responses
• Integrations & connections
• Persistent 3-tier memory system
• Experts with agentic capabilities
• Execution engine (DAG executor)
• Routines (propose, preview, save, schedule)
• Core intelligence + team orchestration
• Activity + approvals
• Sandbox environment
• Connectors (Google Calendar, Gmail, Notion)
• Channels (Telegram, WhatsApp, Email)
• Remote access
• Marketplace
• Onboarding tour

Contributing

Cerebro is built in the open and we'd love your help. Whether it's a bug report, a feature idea, a docs improvement, or a pull request — every contribution matters.

The easiest way to start is to open an issue. We use issues to discuss bugs, plan features, and answer questions before any code gets written.

Ready to contribute code? See CONTRIBUTING.md for setup instructions, PR guidelines, and good first issues.

Star History

If you find Cerebro useful, consider giving it a star. It helps others discover the project.

License

MIT — see LICENSE for details.