Zero Voice 🎙️

A voice-enabled web automation tool powered by ZeroClaw runtime with miniature call center capabilities for automated task management at scale.

🐍 Now Available as a Python Package!

pip install zerovoice

Non-Rust developers can now use Zero Voice through a simple Python API while maintaining the performance of the Rust core.

🚀 Built with ZeroClaw

Zero Voice leverages the ZeroClaw AI assistant runtime for:

• Fast & Lightweight: Runs on minimal hardware with <5MB RAM
• Swappable AI Providers: OpenAI, Anthropic, or custom endpoints
• Multi-Channel Communication: Voice, CLI, Twilio phone calls
• Built-in Tools: Browser automation, HTTP requests, file operations
• Secure by Default: Sandboxing, rate limits, and encrypted secrets

Features

Core Capabilities

• 🤖 AI-Powered Agent: Autonomous task execution with ZeroClaw runtime
• 🎤 Voice Commands: Natural language processing through voice channel
• 📞 Phone Integration: Make and receive automated calls via Twilio
• 🌐 Web Automation: AI-assisted web scraping and browser control
• 🔧 Modular Architecture: Swap providers, tools, and channels easily
• 💾 Persistent Memory: SQLite-backed conversation history

📞 Call Center Features

• Concurrent Call Management: Handle up to 100+ simultaneous calls
• Task Queue System: Intelligent distribution of calling tasks
• Virtual Agent Pool: Multiple AI agents with unique personalities
• Campaign Management: Launch and manage calling campaigns
• Automatic Retries: Smart retry logic for failed calls
• Real-time Monitoring: Track queue size, active calls, and completion rates
• Result Aggregation: AI-powered analysis and summary of call results
• Callback Webhooks: Integration with external systems for result processing

🎭 Conversational AI Features (ElevenLabs-style)

• Natural Back-and-Forth Dialogue: Real conversations, not just scripts
• Context-Aware Responses: Remembers conversation history and adapts
• Emotional Intelligence: Tracks caller mood and adjusts tone accordingly
• Dynamic Personalities: Choose from multiple agent personalities
• Interruption Handling: Natural conversation flow with barge-in support
• Real-time Processing: WebSocket streaming for instant responses
• Objective Tracking: AI pursues conversation goals intelligently
• Sentiment Analysis: Understands caller emotions and frustration

📊 Dashboard & Monitoring (NEW! v0.5.0)

• Web Dashboard: Beautiful real-time monitoring interface
• Call History: Complete log of all calls with details
• Transcript Viewer: Read full conversation transcripts
• Audio Playback: Listen to call recordings directly
• Manual Dialing: Initiate calls from the dashboard
• Live Statistics: Real-time metrics and analytics
• Search & Filter: Find calls by phone number or status
• Callback Management: Mark and track callbacks
• Docker Deployment: One-command deployment with docker-compose

Prerequisites

• Rust (latest stable version)
• ZeroClaw runtime dependencies
• Twilio Account with:
  • Account SID
  • Auth Token
  • Phone Number
• AI Provider API Key (OpenAI, Anthropic, etc.)
• ngrok (for local development with Twilio webhooks)

Installation

Option 1: Python Package (Recommended for Most Users)

# Install from PyPI
pip install zerovoice

# Configure
zerovoice setup --sid YOUR_SID --token YOUR_TOKEN --phone +1234567890

# Launch dashboard
zerovoice dashboard

# Make a call
zerovoice call +1234567890 -m "Hello from Zero Voice"

Option 2: Rust Installation (For Developers)

1. Clone the repository:

git clone https://github.com/collinparan/zero-voice.git
cd zero-voice

2. Install Rust if you haven't already:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

3. Copy the environment template and configure:

cp .env.example .env
# Edit .env with your credentials

4. Build the project:

cargo build --release

Configuration

Create a .env file with the following variables:

# AI Provider (required for ZeroClaw)
OPENAI_API_KEY=sk-...
# or
ANTHROPIC_API_KEY=sk-ant-...

# Twilio Configuration
TWILIO_ACCOUNT_SID=your_account_sid
TWILIO_AUTH_TOKEN=your_auth_token
TWILIO_PHONE_NUMBER=+1234567890

# Webhook Configuration
WEBHOOK_BASE_URL=https://your-domain.ngrok.io

Usage

🐍 Python Quick Start

from zerovoice import CallCenter, configure

# Configure Twilio
configure(
    twilio_sid="your_sid",
    twilio_token="your_token",
    twilio_phone="+1234567890"
)

# Create call center
center = CallCenter(max_concurrent=10)

# Make a call
call_id = center.make_call(
    to_number="+0987654321",
    message="Hello from Python!"
)

# Launch dashboard
from zerovoice.dashboard import run_dashboard
run_dashboard(center, port=8080)

🦀 Rust CLI Quick Start

Configure your AI provider:

zero-voice onboard --api-key sk-... --provider openai

🤖 Agent Mode

Run the AI agent interactively:

# Interactive mode
zero-voice agent

# With voice enabled
zero-voice agent --voice

# Process a single command
zero-voice agent -m "Scrape example.com and summarize the content"

🔄 Daemon Mode

Start the autonomous daemon with all channels:

zero-voice daemon --port 3000

This enables:

• CLI interaction
• Voice commands
• Twilio phone integration
• Web scraping tools
• All ZeroClaw capabilities

📞 Phone Calls

Make an outbound call:

zero-voice call --to "+1234567890" --message "Hello, this is Zero Voice calling!"

🌐 Web Scraping

Scrape websites with AI analysis:

# Default analysis
zero-voice scrape --url "https://example.com"

# Custom prompt
zero-voice scrape --url "https://example.com" --prompt "Extract all email addresses and phone numbers"

📊 Status

Check runtime status:

zero-voice status

🏢 Call Center Mode

Start the miniature call center:

# Start with default 10 concurrent calls
zero-voice call-center

# Custom concurrent limit
zero-voice call-center --concurrent 50 --port 3000

🚀 Launch Campaigns

Execute calling campaigns with task distribution:

# With phone list
zero-voice campaign \
  --numbers "+1234567890,+0987654321" \
  --script "Hello {name}, this is Zero Voice calling about {topic}" \
  --concurrent 20

# From CSV file
zero-voice campaign \
  --file contacts.csv \
  --script "Automated survey about customer satisfaction" \
  --concurrent 30

📈 Monitor Statistics

View real-time call center metrics:

zero-voice stats

🎭 Conversational AI Mode (ElevenLabs-style Agents)

Start the conversational AI server for natural dialogue:

# Basic conversational mode
zero-voice converse

# With streaming audio and custom personality
zero-voice converse --port 3000 --streaming --personality "Jamie"

Available personalities:

• Alex: Professional support agent (patient, knowledgeable)
• Jamie: Friendly sales agent (enthusiastic, persuasive)
• Sam: Empathetic survey conductor (good listener, encouraging)

Configure Twilio for conversations:

1. Set Voice URL to: https://your-domain.ngrok.io/conversation/start
2. Method: POST
3. Enable "Enhanced Programmable SIP Features" for best results

📊 Dashboard

Launch the monitoring dashboard:

# Start dashboard on default port 8080
zero-voice dashboard

# Custom port and database
zero-voice dashboard --port 9000 --database sqlite://calls.db

Access the dashboard at: http://localhost:8080

Dashboard features:

• Real-time Statistics: Live call metrics and success rates
• Call History Table: Sortable list of all calls
• Transcript Viewer: Click any call to see full transcript
• Audio Player: Play recordings directly in browser
• Quick Dial: Make calls from the dashboard
• Search: Find calls by phone number
• Analytics: Hourly/daily call volume charts

Call Center Usage Examples

Example 1: Customer Survey Campaign

# Prepare a CSV file with customer data
echo "phone,name,product
+1234567890,John Doe,Widget Pro
+0987654321,Jane Smith,Widget Lite" > customers.csv

# Launch the campaign
zero-voice campaign \
  --file customers.csv \
  --script "Hello {name}, we're calling about your recent purchase of {product}. How satisfied are you on a scale of 1-10?" \
  --concurrent 5

Example 2: Appointment Reminders

zero-voice campaign \
  --numbers "+1234567890,+0987654321,+1112223333" \
  --script "This is a reminder about your appointment tomorrow at 2 PM. Press 1 to confirm or 2 to reschedule." \
  --concurrent 10

Example 3: Emergency Notifications

zero-voice call-center --concurrent 100  # Start high-capacity center

# In another terminal, launch urgent campaign
zero-voice campaign \
  --file emergency_contacts.csv \
  --script "URGENT: This is an automated emergency notification. Please check your email for important safety information." \
  --concurrent 100

Example 4: Natural Conversation (ElevenLabs-style)

# Start conversational mode
zero-voice converse --personality "Alex" --streaming

# The AI agent can now handle natural dialogue like:
# Caller: "Hi, I'm calling about my recent order"
# Agent: "Hello! I'd be happy to help you with your order. Could you provide your order number?"
# Caller: "Actually, wait, I think it was delivered but I'm not sure"
# Agent: "No problem! Let's figure this out together. When did you place the order?"
# Caller: "Last Tuesday, I think... or was it Monday?"
# Agent: "That's alright, we can look it up. What's the email address associated with your account?"
# [Natural back-and-forth continues with context awareness...]

Architecture

zero-voice/
├── src/
│   ├── main.rs                  # ZeroClaw runtime integration & CLI
│   ├── twilio_channel.rs        # Custom Twilio channel for ZeroClaw
│   ├── call_center.rs           # Call center management system
│   ├── conversation.rs          # Conversational AI state management
│   ├── conversation_webhooks.rs # Real-time dialogue webhooks
│   ├── database.rs              # SQLite database layer
│   └── dashboard.rs             # Web dashboard and API
├── templates/
│   └── dashboard.html           # Dashboard UI
├── migrations/
│   └── 001_initial.sql          # Database schema
├── Dockerfile                   # Container image
├── docker-compose.yml           # Multi-service deployment
├── Cargo.toml                   # Dependencies
└── .env                         # Configuration (not in repo)

Call Center Architecture

• Task Queue: Priority-based queue for call distribution
• Agent Pool: Virtual agents with personalities and voices
• Call Manager: Handles concurrent call execution
• Result Aggregator: Collects and analyzes call outcomes
• Monitoring System: Real-time statistics and health checks

Conversational AI Architecture

• Conversation Manager: Maintains dialogue state and context
• Personality Engine: Different agent personalities with unique traits
• Emotional Tracking: Monitors caller mood and engagement
• Intent Recognition: Understands what callers want in real-time
• WebSocket Streaming: Real-time audio processing for natural flow
• Context Memory: Remembers conversation history for coherent responses

ZeroClaw Integration

Zero Voice extends ZeroClaw with:

1. Custom Twilio Channel: Enables phone call capabilities through ZeroClaw's channel system
2. Voice Commands: Leverages ZeroClaw's voice channel for speech interaction
3. Web Automation: Uses ZeroClaw's browser and HTTP tools
4. AI Providers: Supports all ZeroClaw-compatible providers

Voice Commands

When in agent mode with voice enabled, you can use natural language:

• "Call [phone number] and tell them [message]"
• "Scrape [URL] and find [specific information]"
• "Search for [query] and summarize the results"
• "Check my email" (with appropriate tools configured)
• Any command supported by ZeroClaw tools

Twilio Webhook Configuration

1. Start the daemon: zero-voice daemon --port 3000
2. Use ngrok for local development: ngrok http 3000
3. Configure your Twilio phone number:
   • Voice URL: https://your-ngrok-url.ngrok.io/twiml
   • Status Callback: https://your-ngrok-url.ngrok.io/status

Development

Running Tests

cargo test

Building for Production

cargo build --release

🐳 Docker Deployment

Quick Start with Docker Compose

Deploy the complete system with one command:

# Clone the repository
git clone https://github.com/collinparan/zero-voice.git
cd zero-voice

# Copy environment file and configure
cp .env.example .env
# Edit .env with your credentials

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f

Services will be available at:

• Dashboard: http://localhost:8080
• Call Center: http://localhost:3000
• Conversations: http://localhost:3001

Individual Docker Commands

# Build the image
docker build -t zero-voice .

# Run dashboard
docker run -d -p 8080:8080 \
  -v $(pwd)/data:/app/data \
  -v $(pwd)/recordings:/app/recordings \
  --env-file .env \
  --name zero-voice-dashboard \
  zero-voice /app/zero-voice dashboard

# Run call center
docker run -d -p 3000:3000 \
  -v $(pwd)/data:/app/data \
  --env-file .env \
  --name zero-voice-call-center \
  zero-voice /app/zero-voice call-center --concurrent 50

Production Deployment

For production, use the included docker-compose.yml with:

• Nginx reverse proxy for SSL
• Persistent volumes for data and recordings
• Automatic restart policies
• Health checks

Extending Zero Voice

Adding Custom Tools

Extend ZeroClaw's tool system:

let runtime = zeroclaw::Runtime::new()
    .with_tool(my_custom_tool())
    .build()?;

Custom Channels

Implement the ZeroClaw Channel trait:

impl zeroclaw::Channel for MyChannel {
    fn name(&self) -> &str { "my_channel" }
    async fn send(&self, message: &str) -> Result<()> { /* ... */ }
    async fn receive(&mut self) -> Result<Option<String>> { /* ... */ }
}

Features Roadmap

• ZeroClaw runtime integration
• Voice command processing
• Twilio phone integration
• AI-powered web scraping
• Miniature call center with concurrent call handling
• Task queue and campaign management
• Virtual agent pool with personalities
• Real-time call monitoring
• Natural conversational AI (ElevenLabs-style)
• Web dashboard UI with monitoring
• Call history and transcript viewer
• Audio playback and recording
• Manual dial interface
• Docker deployment
• SMS support via Twilio
• WhatsApp integration
• Advanced analytics with ML insights
• Multi-language support
• Custom webhook integrations

Performance

Thanks to ZeroClaw:

• Runs on devices with <5MB RAM
• Near-instant cold starts
• Single binary deployment
• Cross-platform: ARM, x86, RISC-V

Security

• Sandboxed execution by default
• Encrypted credential storage
• Rate limiting and allowlists
• Never commit .env files
• Use environment variables for sensitive data

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License - see LICENSE file for details

Acknowledgments

• ZeroClaw - The powerful AI runtime that powers Zero Voice
• Twilio - Voice and messaging APIs

Support

For issues and questions, please open an issue on GitHub.

---

Built with ❤️ using ZeroClaw 🦀

Last updated: March 2026