Twenty: Open-Source AI-Native CRM Built as Code

Background and Context

Customer relationship management software is one of the oldest categories in enterprise computing, and commercial vendors such as Salesforce have dominated it for years. The familiar pain is configuration. Fields and processes are clicked together in an admin console. Those settings never enter a code repository, receive no review, and are hard to roll back. When the business changes, teams keep fiddling inside a black-box interface.

Twenty targets exactly this problem. The project has more than 59,000 GitHub stars and positions itself as an open alternative to Salesforce. It states that it was designed for AI from day one. Its core claim is plain: technical teams want a set of building blocks they can assemble, not a finished product with fixed behavior. In the project's own words, Twenty is a CRM you build, ship and version like the rest of your stack.

That sentence marks the key difference from older products. Twenty sits in the business application layer of the open-source ecosystem. It serves engineering teams that want control over both data and code, yet do not want to build a CRM from scratch. It treats the CRM as a programmable platform, so sales, operations and developers can work in one shared language.

Deep Analysis

What does it mean to build a CRM as code? In Twenty, the basic building blocks are objects, views, workflows and agents. Objects map to business entities such as customers or deals. Views decide how data is shown. Workflows handle automation. Agents bring AI directly into business processes. The distinctive step is that these blocks are written in code. The README example uses the twenty-sdk function defineObject to declare a deal object. The developer sets singular and plural names, a display label, and fields such as name, amount and expected close date. The field types are text, currency and date-time. These definitions are ordinary TypeScript files. They can live in Git, pass code review and evolve with versions.

Deployment follows the same logic. A single app:publish command pushes the application to a workspace as a private app. Compared with configuring items one by one in a graphical interface, this makes changes traceable, reproducible and automatable. Twenty also supports coding agents natively. The project ships official Twenty app skills. They work in Claude Code, Codex, Cursor, Pi and other environments supported through the skills CLI, so an AI assistant can help build an app to the project's conventions. The stack is TypeScript and Nx. The backend uses NestJS with BullMQ, PostgreSQL and Redis. The frontend uses React with Jotai, Linaria and Lingui. There are three ways to start. The fastest is a cloud workspace at twenty.com, which the project says takes under a minute and needs no infrastructure work. For custom development, running npx create-twenty-app my-app generates a scaffold. Teams then define objects, fields and views in code and publish them to their workspace. Teams with data-location or compliance needs can self-host with Docker Compose. Typical uses include a deal pipeline with custom fields for sales, tailored views for customer success, and workflows or agents that handle repetitive follow-up. The project also runs a Discord, a roadmap, a feature request channel and Crowdin translation. Its repository topics include good-first-issue and hacktoberfest.

Industry Impact

Twenty matters for more than being another open-source CRM. It shows a direction for business software: from interface configuration, to code definition, to AI agents that help build and run the system. When objects and views are code, a coding agent can read and change them. That explains why the project ships a skill pack for Claude Code, Cursor and similar tools.

For engineering teams, a code-defined CRM can join the same delivery pipeline as other systems. It gains version control, review and automated deployment. For smaller teams, open source and self-hosting reduce the risk of lock-in to a single vendor. Teams that care about data ownership gain a path that Salesforce-style hosted suites do not offer in the same way.

There are real trade-offs. Code-first customization moves the entry barrier to developers, so non-technical staff may not maintain the system alone. Self-hosting also puts operations, backups and upgrades on the team. The README notes that the agent-skills branch is created only after the first successful publish. That detail suggests some supporting features are still maturing, so teams should check current documentation before production use.

Outlook

Several questions will decide how far Twenty goes. First, can its app ecosystem grow into a market of reusable templates? Because apps are plain TypeScript, sharing and reusing them is technically simple. Whether a healthy library appears is still unproven. Second, how reliable are agents inside real sales workflows? The project provides the hooks for agents and for coding-agent skills. The README does not report measured results, so teams should test on their own data before trusting automation with customer contact.

Third, how well does the platform fit large enterprise needs? The source material describes the stack, the deployment options and the developer tooling. It gives no detail on large-scale compliance or governance features, so those points need checking in the documentation. If these areas mature, Twenty could become a representative sample of open-source enterprise software built for the agent era. For now, the clearest fit is a team that wants deep customization of customer workflows, values data ownership, and is comfortable treating its CRM as engineering work.