OpenOutreach
A self-hosted agent for discovering B2B leads and conducting email outreach.
The README unusually clearly discloses lead discovery, paid email resolution, LLM use, SMTP/IMAP access, a central contacts store, affiliate links, and project-promotional mail sent under the user's identity, justifying full data-flow transparency and relatively strong external-effect and attribution scores. Deductions apply because the tests require every opener to send and show no per-message confirmation; the promotional rotation is enabled in the shipped product and disabling it requires source modification, weakening least privilege. Although credentials and personal data are described as locally persisted and legally covered, the supplied evidence shows no encryption, access-control, log-redaction, retention, or deletion controls. CI actions are major-version pinned, but the recommended runtime pulls a latest image and no dependency lock or vulnerability-management evidence is supplied. Pipeline states support resumption and failure handling, but sent mail and purchased lookups cannot be rolled back. Publisher identity remains unknown.
The README, pipeline description, and agent tests are broadly consistent about first-touch sending, reply actions, prompt context, and state transitions. Tests cover missing summaries and malformed opener decisions. Deductions reflect the absence of implementation files and broader tests needed to confirm the complete advertised behavior; a legacy-looking social-profile URN in the test is also a minor inconsistency with the no-social-account framing. Python, Docker, LLM, BetterContact, SMTP, and IMAP requirements are identified with containerized setup, but evidence for third-party availability, retries, and graceful degradation is limited. Failure states and targeted ValueError messages exist, while comprehensive operator-facing diagnostics and recovery instructions are not shown.
Target users, B2B scenarios, required inputs, sending hours, and example campaigns are exceptionally clear, earning full audience-and-scenarios credit. Bring-your-own-model support, compatible endpoints, owned SMTP mailboxes, and Django Admin configuration provide useful flexibility, but discovery and address resolution remain tied to BetterContact and the core channel is email. Pipeline priority, weekday windows, reply-driven follow-up, and spend gating provide reasonable trigger precision, yet first-touch delivery is automatic and no preview, approval, or fine-grained trigger policy is demonstrated. Docker and local Python paths fit ordinary self-hosting, but only a SQLite/single-daemon shape is evidenced, leaving scaling and wider deployment fit underdocumented.
The README has strong organization, a project tree, ordered pipeline explanation, and a documentation index; Docker and local setup instructions are concrete, earning full information-architecture and installation scores. Names and state enums appear stable, and several examples plus testing documentation are referenced, but there is no substantive FAQ in the supplied material. The experimental learning claim, legal responsibilities, and service dependencies are acknowledged, though deliverability, model-error, and scale limitations are not developed. GPLv3 is asserted with a LICENCE.md reference, but repository metadata is NOASSERTION and the license text is absent, so it cannot be fully confirmed. The workflow supports v* releases and semantic image tags, but no changelog or release policy is shown. Support and sponsorship channels exist without a clearly identified maintainer, response commitment, or security-update owner.
Outputs feed a built-in CRM with explicit lead, deal, and conversation states; prompt tests also verify subjects, messages, and reply actions, supporting ordinary operational usability. Deductions reflect the absence of output-quality criteria, a human-review workflow, or documented export formats. Automated discovery, qualification, email resolution, and multi-turn replies offer clear marginal value over manual outreach, but no outcome evidence establishes their effectiveness. Cost gating, daily send capacity, and pay-per-resolved-address behavior are described concretely, while the author appropriately concedes that the learning layer has not beaten random selection. Total costs from LLM use, provider services, mailbox infrastructure, and promotional use of sending capacity remain unquantified.
The README maps principal claims to concrete states, steps, services, and source directories, while tests corroborate context construction, permitted actions, first-touch constraints, and recent-message handling. This supports good traceability and partial cross-source corroboration. Deductions apply because many security, legal, cost, and data-handling claims appear only in the README, while the referenced legal, architecture, and configuration files were not supplied for checking. Fact-versus-inference separation is excellent: the learning loop is expressly labeled experimental, its failure to demonstrate an advantage over random selection is disclosed, and no unsupported performance claim is made, justifying full marks.
- The tool automatically sends cold email from the user's mailbox; the supplied tests show that a first-touch decision must send, with no per-message preview or confirmation evidenced.
- The bundled promotional campaign sends OpenOutreach advertising under the user's identity to recipients unrelated to the user's leads and consumes part of the sending rotation; disabling it on the shipped install requires source modification.
- The user bears anti-spam and data-protection responsibility. The static material does not establish consent management, jurisdictional compliance, deletion-request handling, or retention controls.
- LLM, BetterContact, and mailbox credentials are required, but encryption at rest, secret isolation, log redaction, and credential-incident procedures are not evidenced.
- The recommended command always pulls the latest container image. Production users should pin a reviewed immutable digest and independently inspect dependencies and image contents.
- BetterContact lookups, LLM calls, mailbox services, and promotional traffic may create financial and reputational costs; total cost and deliverability risk are not quantified.
What does this agent do, and when should you use it?
OpenOutreach is a self-hosted, email-first B2B sales automation system that discovers, qualifies, and contacts prospects from a product description and target-market objective. Its core is a Django application with a continuously cycling daemon, SQLite-backed Lead, Deal, conversation, and pipeline state, plus a Django Admin CRM. Prospect profiles come from BetterContact Lead Finder, while FastEmbed, a Gaussian Process Regressor, and an LLM determine which candidates to assess and when to spend a credit on work-email resolution. Qualified prospects receive personalized openers through the operator's SMTP mailbox; replies are retrieved through IMAP and handled through multi-turn agentic messaging. It can run from a prebuilt Docker image or a Python 3.12+ source installation, keeping application data on the operator's host while relying on network services for discovery, enrichment, model inference, and email transport.
OpenOutreach reads a product description and Campaign objective, asks an LLM to produce an ICP filter and initial search terms, and pages licensed firmographic profiles through BetterContact Lead Finder. It embeds those profiles into 384-dimensional FastEmbed vectors; a Gaussian Process Regressor chooses candidates by predicted qualification probability or BALD score, while every actual qualification decision is made by the LLM and fed back into the model. The daemon handles work in a fixed order: poll an email-lookup job, answer an inbound reply, send a first email, rank the candidate pool, buy an address, or discover and qualify more leads. A confidence gate advances suitable Deals from QUALIFIED to READY_TO_FIND_EMAIL; a BetterContact hit moves them to READY_TO_EMAIL, after which SMTP delivers a personalized opener. IMAP retrieves responses, and the outreach agent can reply, close the Deal, or honor an unsubscribe. SQLite stores pipeline and conversation state for resumable execution, and Django Admin exposes the local CRM; cold outbound mail is limited to Monday through Friday, 08:00–20:00 in the operator's timezone, with a daily cap per mailbox.
- A B2B founder without an existing contact list can start from a product description and target role, then let the system discover and contact prospects.
- A sales team avoiding browser automation, social-network accounts, and scraping can use licensed firmographic data and mailboxes it controls.
- An organization that needs Lead, Deal, and conversation records on its own infrastructure can manage them through the bundled Django Admin CRM.
- An outbound team trying to constrain enrichment spend can use model ranking and the confidence gate to reserve paid work-email lookups for stronger candidates.
- An agency running separate outreach initiatives can configure Campaign records with distinct products, target markets, capacity, and model settings.
What are this agent's strengths and limitations?
- It does not require a supplied contact list: it derives an ICP from the product and objective and discovers candidates through a licensed source.
- It uses no browser, social-network account, or scraping workflow, avoiding the account-ban surface associated with those mechanisms.
- Paid email resolution is gated by both model confidence and daily sending capacity, reducing the chance of buying addresses that cannot be used promptly.
- Lead, Deal, pipeline, and conversation data remain in a local database and are inspectable through Django Admin.
- The LLM layer supports OpenAI, Anthropic, and OpenAI-compatible endpoints, providing model-provider flexibility.
- Both discovery and work-email resolution depend on BetterContact, and no drop-in path for another discovery provider is documented.
- Operation requires an SMTP/IMAP mailbox, an LLM API key, and a BetterContact key; external inference and enrichment may incur costs.
- The repository explicitly describes its Gaussian Process learning loop as experimental and does not claim it outperforms random candidate selection.
- Freemium operation rotates in promotional emails for OpenOutreach, sent from the operator's mailbox to recipients unrelated to the operator's leads; disabling it requires editing the GPLv3 source.
- The operator remains responsible for anti-spam and data-protection compliance for both its outreach and the project's promotional mail.
- The supplied repository metadata reports NOASSERTION for the license while the README identifies GNU GPLv3; adopters should verify the actual LICENCE.md before use.
How do you install or deploy this agent?
The recommended deployment uses Docker. First obtain an LLM API key, a BetterContact API key, and credentials for an SMTP/IMAP mailbox you own, then run:
docker run --pull always -it -v ~/.openoutreach/data:/app/data ghcr.io/eracle/openoutreach:latestOn first launch, the interactive onboarding collects the product and objective, verifies the LLM key, checks SMTP authentication, and configures BetterContact, the email address, country, and newsletter/legal options. Persistent data is stored under ~/.openoutreach/data. For source development, install Git and Python 3.12+, then run:
git clone https://github.com/eracle/OpenOutreach.git
cd OpenOutreach
make setup
make runHow do you use this agent?
During onboarding, enter a product description and Campaign objective, such as selling a SaaS analytics platform to VPs of Engineering at Series B startups. Configure OpenAI, Anthropic, or an OpenAI-compatible endpoint, provide the BetterContact key, and connect an owned SMTP/IMAP mailbox. Keep the daemon running so it can discover profiles, qualify candidates, resolve addresses within sending capacity, send first messages, and process replies. To inspect the CRM from a source installation, run python manage.py createsuperuser once, then make admin, and open http://localhost:8000/admin/. SiteConfig and Campaign are configurable through Django Admin, and the persisted pipeline resumes after the daemon is stopped and restarted.