Twenty 2.0 Launches Open-Source CRM Platform for Developers

Twenty 2.0 ships an open-source CRM platform that lets developers define data models, workflows, and layouts entirely in code, with built-in AI agents and self-hosting baked in from the start.

The pitch is straightforward enough that it almost sounds unremarkable until you sit with it. Most CRM software forces you into one of two bad deals. You either buy something expensive and opinionated from a legacy vendor, spend six months configuring it through a UI that was designed by someone who hates you, and end up with a system that technically works but will never do exactly what you need. Or you decide to build something custom and discover, around month three, that you’ve accidentally signed up to be a CRM company. Twenty 2.0 is trying to cut a third path: an open-source foundation you actually own, with an SDK that lets you extend it through your normal development workflow instead of around it.

The core of Twenty 2.0 is that everything configurable lives in code. Custom objects, data models, layouts, navigation, serverless functions, widgets, automated workflows. You define them through the SDK, ship them through the same pull request process you already use for everything else, and the AI tools already living in your editor can help write them. That last part isn’t incidental. The team positioned “AI-friendly SDK” as the lead descriptor for a reason. If your development workflow now includes Cursor or similar tools handling significant chunks of boilerplate, a CRM that fits into that flow is categorically different from one that requires you to click through a configuration panel.

The self-hosting piece matters too, and not just philosophically. For any company working with customer data under serious compliance constraints, the question of where that data actually lives is non-negotiable. “Fully yours” is the tagline, and it’s doing real work there.

The CRM market has been consolidating around a few large players for a long time, and the developer tooling market is moving fast in the other direction. According to market research cited by Business Research Insights, the software development tools market sat at $8.67 billion in 2026 and is projected to reach $33.9 billion by 2035, growing at a 14.5% CAGR. The AI-native slice of that is moving faster. The generative AI segment in developer tools was tracking toward an 84.4% CAGR through 2028, according to reporting from Medium’s tech coverage. Those numbers aren’t surprising if you spend any time around developers right now, but they do explain why building an AI-native SDK into a CRM platform in 2026 is a different calculation than it would have been in 2022.

The selfhosted community on Reddit has been paying attention. Twenty 2.0 lets you build apps on top of the CRM without forking the codebase, which was a consistent complaint about earlier versions. Forking to customize is how you end up stranded. Every upstream update becomes a conflict resolution exercise, and most teams quietly stop pulling updates entirely after the second painful merge. If the SDK genuinely removes that constraint, it solves a real problem for the kind of technically sophisticated teams who want open-source software but also want to stay current.

Worth being clear about what the product is and isn’t at this stage. The source material describes capabilities but the website wasn’t available for review, so some specifics about pricing tiers, hosting requirements, and exactly how the custom agents work in practice are drawn from the Product Hunt listing rather than documentation. The full product details are available for developers who want to get into the specifics before committing time. The launch did well when it hit Product Hunt, landing the number two daily rank.

What I find interesting about the framing is the word “enterprise” in the tagline. “Build your Enterprise CRM with an AI-friendly SDK.” Enterprise is doing a specific kind of work there. It’s not describing the current state of the product, necessarily. It’s describing the ambition and the use case being targeted. Enterprise sales teams have complex data models. They have approval workflows that don’t fit any template. They have sales stages that evolved through years of acquired institutional knowledge about how their specific customers actually buy. Most CRM platforms are designed around a generalized model of sales that may or may not match yours. Twenty 2.0’s argument is that you should be able to describe your actual model in code and have the CRM conform to it, rather than the reverse.

Custom agents are listed as a built-in feature. This is where I’d want to spend more time in the actual product before drawing firm conclusions. “AI built in” covers a lot of territory in 2026. It can mean an AI assistant that summarizes call notes, or it can mean a proper agent runtime where you define what information the agent has access to and what actions it can take. The SDK framing suggests it’s closer to the latter, since you’re supposed to be able to define agent behavior in code rather than configure it through a UI. But the implementation quality of this kind of feature varies enormously across products right now, and “built in” without specifics is a claim that needs to be tested against a real workflow.

The serverless functions capability is more immediately legible. Defining logic that runs in response to CRM events, shippable through your normal dev flow, is a concrete and useful feature. If a deal moves to a certain stage, trigger a function. If a contact record gets created with certain attributes, do something. That kind of event-driven extension is what makes a CRM actually integrate into a company’s operations rather than sit alongside them.

The GNU Affero General Public License, which governs many self-hosted open-source projects, creates an interesting tension for commercial products built on open-source foundations. It’s worth checking Twenty’s specific licensing terms if you’re building something commercial on top of it, since AGPL in particular has implications for network-deployed applications that copyleft doesn’t always register until it matters. The source material doesn’t specify Twenty’s license explicitly, so I’m not going to state it, but any team planning to build a commercial application on top of an open-source CRM should check that before the architecture gets too entrenched.

The comparison point most people will reach for is Salesforce, which makes sense and also somewhat misses the point. Salesforce has decades of integrations, an enormous partner network, a certification industry, and a procurement process that itself takes months. Twenty 2.0 is not trying to win Salesforce’s existing customers through a feature checklist comparison. It’s trying to be the right answer for technical teams who don’t want to start that process in the first place.

The more interesting comparison might be to something like Attio or folk, both of which tried to rethink the CRM for modern teams. The SDK and code-first approach is a distinct bet, though. It says: your developers are already building things, let them build the CRM too, rather than requiring a separate category of CRM-specialist work. Whether that resonates depends heavily on who owns CRM decisions at a given company. At a 20-person company where the founder still writes code, this is an easy yes. At a 200-person company with a RevOps team and no eng support, it’s not the product.

The four-day launch rollout mentioned in the LinkedIn company page research is a curious choice. Staggered launches can build momentum, but they can also dilute the initial spike. It suggests the team had enough new material to spread across multiple days rather than dropping everything at once, which is a reasonable signal that Twenty 2.0 is a meaningful version increment rather than a point release dressed up as a major one.

“We’re launching Twenty 2.0 and it’s so big we’ll need four days to cover it,” the company said in a LinkedIn update ahead of the release.

For a developer considering whether to evaluate it: the self-hosted, code-first CRM category is real and genuinely underserved. The risk is adoption overhead. Open-source tools that require your team to actually read documentation and make architectural decisions are not neutral on time cost. The SDK’s quality, the documentation, and the developer experience will determine whether Twenty 2.0 is a faster path to a working CRM than the alternatives, or just a different kind of configuration work. The people best positioned to make that call are the ones already living in their code editor, already running infrastructure they own, and already tired of paying per seat for software that doesn’t fit their data model.