Open Source Attio Alternatives

Most CRMs are configured through a settings screen and drift away from the rest of your engineering practice. Twenty treats the CRM as software you build, ship and version like anything else in the stack, handing technical teams primitives instead of checkboxes.

Work starts by scaffolding an app with the Twenty CLI and declaring objects, fields and views in TypeScript. A deal object with its name, amount and close date is a few lines of definition, and one publish command pushes it into your workspace, privately if you choose.

The building blocks cover the shape of a modern CRM.

• Objects and fields: typed definitions describe your data model rather than a fixed schema.
• Views and layouts: how records display is customizable and travels with the app itself.
• Workflows: automation sits alongside the data it acts on, inside the same workspace.
• AI agents and chat: agents work over CRM records, documented for developers and users alike.
• Version control: apps are published and tracked the way the rest of your code is.

The backend is NestJS with BullMQ, PostgreSQL and Redis, and the frontend is React with Jotai, Linaria and Lingui. Self-hosting uses Docker Compose, a local setup guide covers contributors, and a hosted workspace spins up in under a minute.

Most CRMs are a database with a form in front, and the AI ones bolt a chat box onto the form, leaving the real work of finding out what is true and writing it down to a person. Comp AI CRM inverts that. The agent is not a feature of the CRM; the CRM is where the agent keeps its notes.

The agent is its own deployment, built on eve, a filesystem-first framework for durable agents where a tool is a file and a skill is a markdown file. It works from a queue rather than a request, leasing due rows so two dispatchers take disjoint work and a dead run frees its row when the lease expires. Close the browser and it carries on.

A few decisions shape what it will and will not do.

• Nothing is guessed: no tool accepts a confidence score, tools report what they observed and a ledger prices the evidence.
• Weak evidence waits: strong evidence writes to the record, weak evidence becomes a suggestion a human settles.
• Sandbox without exits: the shell has deny-all egress and never receives the database credentials.
• Optional sources: it reads your own threads, meetings and signature blocks before any vendor.
• Visible work: every contact, company and deal has an Agent tab showing steps taken and leads discarded.

It runs on Bun with Postgres under an MIT license. Every outside data source is optional, so an install with no API keys still works from the evidence already in your own mailbox.

Most CRMs hand you a settings page and hope it covers what you need. Atomic CRM hands you the source instead. It is a full-featured CRM you fork, run locally, and change wherever the defaults do not fit, from custom fields and themes down to replacing individual components.

The front end is React with shadcn-admin-kit, and the backend is Supabase, which brings Postgres, a REST API, attachment storage, and authentication in one local stack. One make install command sets up both halves including a local Supabase instance, and make start runs the Vite dev server, the API, and Postgres in Docker. Unit tests use Jest and end-to-end tests use Playwright.

The feature set covers what a small sales team tracks.

• Contacts and notes: contact records with notes capturing details as they surface.
• Deals: a Kanban board for visualizing and tracking the sales pipeline.
• Tasks and reminders: follow-ups and deadlines attached to the work they belong to.
• Email capture: CC the CRM on a message and it is saved as a note automatically.
• Activity history: interactions aggregated into a single log.
• Access control: sign-in through Google, Azure, Keycloak, and Auth0.

Because customization means forking, staying current becomes its own problem, and the project answers it with a shadcn registry: one command pulls upstream component changes into your fork, so commit first and review the diff against your own edits. Local development needs Make, Node 22 LTS, and Docker, and a hosted demo is online if you want to look before cloning.

At the center of Relaticle, a self-hosted CRM, sits a production-grade MCP server. Connecting an agent to customer data normally means writing an integration against someone else's API and hoping the vendor keeps it working; here the tools ship with the CRM and the records never leave your server.

The application is built on Laravel and Filament, so operators get a Livewire interface and an ecosystem many PHP teams already know. Requirements are PHP 8.5 or later, PostgreSQL 17 or later, Composer 2, and Node.js 22 or later, with Redis for queues and optional during development. Installation is a git clone followed by a single composer command.

The project names its strengths in five areas.

• Agent-native infrastructure: an MCP server with 37 tools, plus a REST API with full CRUD, schema access, activity history, and pipeline analysis.
• Customizable data model: 22 field types covering entity relationships, conditional visibility, and per-field encryption, with no migrations needed.
• Multi-team isolation: five layers of authorization with team-scoped data and separate workspaces.
• Modern tech stack: Laravel 13, Filament 5, PHP 8.5, and more than 2,000 automated tests.
• Privacy first: self-hosted under AGPL-3.0, with your data staying on your own server.

A self-hosting guide covers Docker and manual deployment. The repository ships English only, but the codebase is ready for internationalization, so a fork can drop a language directory into place and translate the whole app. It fits developer-led teams, AI-forward startups, and smaller businesses that want agent integration without vendor lock-in.

Warpdrive reimplements the business development workflow of Pipedrive as software you run yourself. It is single-tenant by design: your own box, your own Postgres and object storage, your own Google Workspace for sign-in. Customer data never leaves your infrastructure and there is no per-seat bill.

It is built with Next.js and React on TypeScript, Drizzle ORM over Postgres, and tRPC with TanStack Query. Realtime updates ride a self-hosted WebSocket server backed by Postgres LISTEN and NOTIFY, files go to MinIO or any S3-compatible store, and email runs through the Gmail API.

The scope stops at the core loop and says so plainly.

• Pipeline: a kanban board with custom stages, multiple pipelines, weighted totals, rotting-deal indicators and saved filters.
• Deal workspace: one timeline holding activities, notes, files, email and the full change history.
• Contacts: people and organizations with JSONB custom fields, firmographics, a leads inbox and CSV import with an undo step.
• Two-way Gmail: send and receive with thread linking, templates, signatures, merge fields, scheduled send, and open and click tracking.
• Team platform: role-based permissions, user management, notifications and basic funnel statistics.

Self-hosting is a single-box Docker topology of app, WebSocket server, worker, Postgres, MinIO and Caddy, which provisions TLS automatically. Products, invoicing, multi-currency, web forms and native mobile apps are deliberately out of scope, and integration tests run against a real Postgres rather than a mock.