Run AI-powered cold outreach campaigns on your laptop. No cloud dependencies, no context window limits, no API costs.
Cold Runner is a desktop application that automates cold outreach (job applications, sales, partnerships) using local AI models. Unlike cloud-based tools that burn through context windows and rack up API costs, Cold Runner uses a stateless architecture that works efficiently with small, local models.
The Problem with Existing Tools
Tools like OpenClaw pioneered AI-powered outreach but have a critical flaw: they maintain conversation history in memory, causing context windows to grow unbounded. This means:
- ❌ You need expensive, large-context models (32k+ tokens)
- ❌ High compute requirements even for local inference
- ❌ Dependency on cloud providers for practical use
- ❌ Escalating API costs as campaigns scale
Cold Runner's Solution
We redesigned the architecture from the ground up:
- ✅ Stateless AI calls - Each operation uses only the data it needs, no conversation history
- ✅ Small model friendly - Works great with 7B models (Mistral, Llama 3.2)
- ✅ Runs on laptops - 8GB RAM is enough for full functionality
- ✅ 100% local - Your data never leaves your machine
- ✅ Zero API costs - No OpenAI, Anthropic, or cloud inference bills
- Uses Ollama for local inference (Mistral, Llama, Qwen, etc.)
- Intelligent lead discovery and email generation
- Works offline once models are downloaded
- Built-in setup wizard for one-click Ollama installation
- Brave Search API integration
- Crunchbase, GitHub, Y Combinator scraping
- Automated email finding (Hunter.io + pattern matching)
- Founder/decision-maker identification
- AI-generated personalized emails
- Template system with variable substitution
- Multi-type support (jobs, sales, partnerships, investors)
- Extensible adapter pattern for custom outreach types
- Cron-based scheduled campaigns
- Rate limiting and throttling
- Campaign analytics and tracking
- Run history with success/failure logs
- Natural language queries over your outreach data
- SQL generation with safety checks
- Interactive data exploration
- Export results to CSV
- Built with Electron + Next.js
- Single-user mode (no authentication needed)
- SQLite database (portable, no server required)
- Cross-platform (macOS, Windows, Linux)
Cold Runner's architecture is designed for efficiency and developer experience:
┌─────────────────────────────────────────────────┐
│ Electron (Desktop Shell) │
│ - Window management │
│ - Native OS integration │
│ - Hidden background server process │
└─────────────────┬───────────────────────────────┘
│
┌─────────────────▼───────────────────────────────┐
│ Next.js 15 (Backend Server) │
│ - API routes for all operations │
│ - Standalone build (self-contained) │
│ - React 19 UI │
└─────────────────┬───────────────────────────────┘
│
┌─────────────────▼───────────────────────────────┐
│ Core Modules │
│ - Lead finder (multi-source) │
│ - Job scheduler (cron-based) │
│ - Adapter system (extensible outreach types) │
│ - Setup wizard (Ollama installation) │
└─────────────────┬───────────────────────────────┘
│
┌─────────────────▼───────────────────────────────┐
│ Data Layer │
│ - SQLite with better-sqlite3 │
│ - Umzug migrations (industry-standard) │
│ - 278 tests (unit + property-based) │
└─────────────────────────────────────────────────┘
Key Design Decisions:
- Stateless AI: Each LLM call is independent, no conversation history
- Webpack over Turbopack: Better native module support for production
- Explicit externals: Native modules (better-sqlite3, playwright) properly externalized
- Dynamic ports: Prevents conflicts when running multiple instances
- Node.js 18+ and npm
- macOS, Windows, or Linux
- 8GB RAM minimum (16GB recommended)
# Clone the repository
git clone https://github.com/darula-hpp/cold-runner.git
cd cold-runner
# Install dependencies
npm install
# Set up environment variables
cp .env.example .env
# Edit .env with your API keys (Brave Search, Hunter.io)
# Run database migrations
npm run migrate
# Start development server
npm run electron:devThe app will:
- Launch the Electron window
- Start the Next.js dev server on port 3000
- Open the setup wizard if Ollama isn't installed
# macOS
npm run dist:mac
# Windows
npm run dist:win
# Linux
npm run dist:linuxThe built app will be in the dist/ folder.
Add these to your .env file:
# Brave Search (for lead discovery)
BRAVE_API_KEY=your-brave-api-key
# Hunter.io (for email finding)
HUNTER_API_KEY=your-hunter-api-key
# Ollama (local AI)
OLLAMA_URL=http://localhost:11434
OLLAMA_MODEL=mistralCold Runner works with any Ollama model, but we recommend:
- mistral (7B) - Best balance of speed and quality
- llama3.2 (3B) - Fastest, good for high-volume campaigns
- qwen2.5 (7B) - Excellent for technical content
Install a model:
ollama pull mistralConfigure your regions, templates, and outreach preferences in Settings.
Use the Lead Search to find companies and contacts:
- Enter search queries (e.g., "YC startups hiring engineers")
- AI automatically enriches with emails and decision-makers
- Review and save promising leads
Schedule automated outreach campaigns:
- Select lead type (jobs, sales, etc.)
- Choose template and customize
- Set schedule (cron expression)
- Monitor results in real-time
Use the Data Chat interface to analyze your campaigns:
- "Show me all applications sent this week"
- "Which companies have the highest response rate?"
- "Export all leads from San Francisco"
cold-runner/
├── app/ # Next.js app directory
│ ├── api/ # API routes
│ ├── chat/ # Data chat interface
│ ├── setup/ # Setup wizard
│ └── outreach-scheduler/# Campaign management
├── modules/ # Core business logic
│ ├── lead-finder/ # Multi-source lead discovery
│ ├── scheduler/ # Cron job management
│ ├── setup/ # Ollama installation
│ └── adapters/ # Outreach type adapters
├── agent-core/ # AI/LLM integration
├── db/ # Database and migrations
├── electron/ # Electron main process
└── __tests__/ # Test suites
# Run all tests
npm test
# Run with coverage
npm run test:coverage
# Watch mode
npm run test:watch# Run pending migrations
npm run migrate
# Check migration status
npm run migrate:status
# Create new migration
npm run migrate:create my-migration-name
# Rollback last migration
npm run migrate:rollback
# Fresh database (dev only)
npm run migrate:freshCold Runner uses an adapter pattern for different outreach types:
// modules/adapters/my-adapter.ts
import { BaseAdapter } from './base';
export class MyAdapter extends BaseAdapter {
async generateEmail(target: any, template: string): Promise<string> {
// Your custom email generation logic
}
async enrichTarget(target: any): Promise<any> {
// Your custom enrichment logic
}
}
// Register in modules/adapters/registry.ts
registry.register('my-type', new MyAdapter());Implement the discovery source interface:
// modules/lead-finder/sources/my-source.ts
export async function searchMySource(query: string): Promise<Lead[]> {
// Your scraping/API logic
return leads;
}We welcome contributions! Please see CONTRIBUTING.md for guidelines.
- Windows/Linux testing and bug fixes
- Additional lead sources (LinkedIn, Apollo, etc.)
- More outreach adapters (investor outreach, PR, etc.)
- UI/UX improvements
- Documentation and tutorials
- Multi-user support with authentication
- Cloud sync (optional, for backup)
- Browser extension for one-click lead capture
- A/B testing for email templates
- Response tracking and follow-up automation
- Integration with email providers (Gmail, Outlook)
- Mobile companion app
MIT License - see LICENSE for details.
- Inspired by OpenClaw's vision of AI-powered outreach
- Built with Ollama for local AI inference
- Uses Next.js and Electron
Built with ❤️ for developers who want to own their outreach infrastructure.