Twenty CRM: The Open-Source, AI-Driven CRM for Marketing Agencies

What is Twenty?

Twenty is an open-source CRM platform designed as a modern, flexible alternative to Salesforce, HubSpot, and Pipedrive.¹²

Think of it as a customizable business operating system for structured data, workflows, and relationships. While it ships as a CRM by default, Twenty is intentionally built as a generic platform you can mold into:

A CRM
A lightweight project manager
A sales + delivery tracker
A client ops database
A workflow automation hub

Key characteristics:¹³

Open-source (AGPL license)
Self-hostable with full data ownership
API-first (REST and GraphQL)
Developer-friendly monorepo (TypeScript, NestJS, PostgreSQL, Redis, React)
Modern UX similar to Notion / Airtable / Linear

Core Capabilities

Standard CRM Features²⁴

Contacts (People) and Companies
Opportunities (Deals / Sales pipeline)
Tasks & reminders with due dates and assignees
Notes, emails, attachments
Activity timelines per record
Calendar events and Files

Custom Data Models¹²

You can create:

Custom objects (e.g., Projects, Campaigns, Websites, Clients)
Custom fields (text, number, select, relations, etc.)

Every custom object:

Appears in the UI automatically
Gets API endpoints automatically
Can be filtered, grouped, and visualized

Views & UX¹²

Table / spreadsheet views
Kanban boards
Filters, saved views, sorting, group-by
Relationship linking (People ↔ Companies ↔ Deals ↔ Tasks)

Workflow Automation¹⁴

Trigger → Action automations:

New lead → create follow-up task
Deal marked “Won” → notify Slack + create onboarding tasks
Field change → update related records

Role-Based Permissions⁵¹

Custom roles
Field-level and object-level access
API-key–scoped roles

Can It Manage Tasks?

Yes. Tasks are a first-class feature:²⁴

Assign tasks to users
Set due dates
Link tasks to contacts, companies, or deals
View all tasks in one place (Kanban or table)
Automate task creation via workflows

This makes Twenty viable as a CRM + lightweight task manager, especially for client follow-ups, sales ops, and project milestones.

Hosting Options

Option 1: Official Cloud (Fastest)

Fully hosted by Twenty
No infrastructure to manage
Best for speed and simplicity

Option 2: Self-Hosting (Recommended for Control)⁵⁶

Self-host Twenty on a cloud VM (Hetzner, AWS, DigitalOcean, EC2) with Docker.

Requirements:

Linux server
Docker + Docker Compose
Minimum 2GB RAM

One-Line Install:

curl -fsSL https://get.twenty.com | bash

Manual Setup:⁵

Create .env file (secrets, DB config)
Download docker-compose.yml
Run: docker compose up -d
Access at http://localhost:3000

Docs: docs.twenty.com/developers/self-host/self-host

Where Does Twenty Store Data?

Default storage:⁶¹

Component	Purpose
PostgreSQL	Primary data store for all CRM records and metadata
Redis + BullMQ	Caching and background job queues
S3-compatible storage	File uploads (configurable)

If you self-host, you fully own the data.

Can It Use Supabase?

Yes — with configuration.⁷⁶

Supabase provides fully managed PostgreSQL, so you can point Twenty at a Supabase Postgres instance:

Use the Supabase database connection string as your PostgreSQL URL in Twenty’s environment variables
Twenty reads/writes CRM data to Supabase Postgres
Centralize data, backups, and observability in Supabase’s tooling

For file storage: Supabase Storage is S3-compatible and can be configured as Twenty’s file backend.

Note: Some Postgres extensions may need manual setup, and Supabase schema permissions require care. See community discussion.

Does Twenty Have an API?

Yes — both REST and GraphQL.⁸

API Types

API	Purpose	Endpoints
Core API	Work with records (People, Companies, Opportunities, Tasks)	`/rest/` or `/graphql/`
Metadata API	Manage schema (objects, fields, relationships)	`/rest/metadata/` or `/metadata/`

Key Characteristics⁸

Auto-generated per workspace data model
Standard and custom objects treated the same
Batch operations: Up to 60 records per call
Rate limit: 100 API calls per minute
Built-in REST and GraphQL playgrounds

Authentication

Authorization: Bearer YOUR_API_KEY

API keys are created in Settings → APIs & Webhooks with role assignment for scope.⁸

Example Endpoints

GET  /rest/people
GET  /rest/companies
GET  /rest/opportunities
GET  /rest/tasks
POST /graphql

Webhooks

Subscribe to events and push updates to external systems — ideal for automation and integrations.⁸

MCP, CLI, and Coding Agents

Does Twenty Have an Official CLI?

No official CLI at this time.

Does Twenty Support MCP?

Yes — via community MCP server.⁹¹⁰

The Twenty MCP Server provides Model Context Protocol access for AI agents.

What the MCP Server Enables

An AI agent can:⁹¹⁰

Search contacts and companies
Create/update/delete records
Manage opportunities and pipeline stages
Create & complete tasks
Add notes and activities
Query CRM data with natural language

Example AI Workflows

"Find all active clients without a follow-up task and create one for next week."

"List the 10 most recently created leads."

"Create a new person with name Jane Doe, email jane@example.com, and tag them as 'Google Ads Lead'."

"Update the opportunity for Bright Futures Preschool to stage 'Proposal Sent' and value 12,000."

MCP Setup (High Level)⁹¹⁰

Self-host or use cloud Twenty, ensure API is reachable
Create an API key in Settings → APIs & Webhooks
Configure the MCP server with your Twenty base URL and API key
Register the MCP server in your AI client (e.g., Claude Desktop config)

Compatible with:

Claude (MCP-native)
Custom agent frameworks
Tool-calling LLMs

This gives you a fully AI-driven CRM layer: the agent can read/write everything your API key allows.

How a Marketing Agency Can Use Twenty

1. Sales CRM

Leads → Deals → Clients pipeline
Revenue forecasting
Follow-up automation

2. Client Management

One record per client with contacts, notes, files, emails
Full relationship history
Activity timelines

3. Task & Ops Management

Sales follow-ups
Project milestones
Client check-ins
Internal reminders

4. Project Tracking (Custom Objects)²¹

Create custom objects for:

Object	Example Fields
Campaign	Channel mix, Budget, Target CPL/ROAS, Start/end dates, Status
Deliverable	Type (Landing page, Creative batch), Due date, Assigned user
Project	Client, Timeline, Status, Related campaigns
Website	URL, Hosting, Analytics ID, Client

Link them to Clients, Deals, and Tasks.

5. Automation Hub

Lead capture → CRM
Deal won → onboarding workflow
Inactivity → follow-up reminders

6. AI-Assisted Ops⁹

With MCP + APIs:

"Show all clients with retainer > $5,000 that haven't had a task completed in 14 days."

"Create a new campaign for Northstar Preschools: Google Ads Q2 2026, budget $18,000, and assign three kickoff tasks."

"Summarize current open opportunities by stage and expected MRR."

Alternatives to Consider

CRM	Best For	Strengths	AI/MCP Story
Twenty	Modern teams wanting Salesforce power + Notion UX	Custom objects, REST/GraphQL, active MCP server	Best-in-class for AI-first CRM
SuiteCRM	Traditional B2B sales, Salesforce refugees	Mature, many modules, workflow engine	Older UI, no native MCP
Odoo CRM	Teams needing full ERP (accounting, inventory)	Tight ERP integration, huge module ecosystem	Overkill for CRM-only; AI is DIY
EspoCRM	Lightweight, flexible deployments	Easy to host, REST API, solid core	No dedicated MCP ecosystem
Frappe CRM	ERPNext users	Python extensibility, Frappe ecosystem	DIY AI integration

For an AI-driven, MCP-based workflow, Twenty currently has the cleanest story.¹¹³⁹

Recommended Architecture for an Agency

┌─────────────────────────────────────────────────────────────┐
│                        AI Layer                              │
│  ┌─────────────────┐    ┌─────────────────────────────────┐ │
│  │  Claude/Agent   │───▶│  Twenty MCP Server              │ │
│  │  (MCP Client)   │    │  (Natural language → API calls) │ │
│  └─────────────────┘    └─────────────────────────────────┘ │
└─────────────────────────────┬───────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────┐
│                       App Layer                              │
│  ┌─────────────────────────────────────────────────────────┐│
│  │  Twenty CRM (Self-hosted on EC2/VPS via Docker)         ││
│  │  REST API + GraphQL + Webhooks                          ││
│  └─────────────────────────────────────────────────────────┘│
└─────────────────────────────┬───────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────┐
│                      Data Layer                              │
│  ┌──────────────────────┐  ┌──────────────────────────────┐ │
│  │  Supabase Postgres   │  │  Redis (Cache/Queue)         │ │
│  │  (Primary CRM data)  │  │  (On EC2 or managed)         │ │
│  └──────────────────────┘  └──────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

This gives you:

Full data ownership via Supabase
First-class CRM tailored to your agency
AI agent that operates the CRM via MCP and APIs
Webhook integrations to external automations

Bottom Line

Twenty can realistically become your agency’s internal operating system.

It replaces:

CRM
Light project management
Client tracking spreadsheets
Manual follow-ups
Fragmented tools

And it scales with you, stays developer-friendly, and supports automation + AI in ways most CRMs do not.