# What Is the Recommended Size of an Agile Team? | LinearB Blog > What is the recommended size of an agile team? We’ll discuss how different agile methodologies handle this issue, and why team size matters. _This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._ [Blog](https://linearb.io/blog) / What Is the Recommended Size of an Agile Team? # What Is the Recommended Size of an Agile Team? ![Photo of Carlos Schults](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0) By [Carlos Schults](https://linearb.io/blog/what-is-the-recommended-size-of-an-agile-team#carlos-schults) | July 1, 2021 ![leon_Oalh2_Moj_Uuk_unsplash_scaled_ad4e2ebef4](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/leon_Oalh2_Moj_Uuk_unsplash_scaled_ad4e2ebef4?_a=BAVMn6ID0) One of the most common questions people ask when trying to implement agile is “What is the recommended size of an agile team?” Even though you’ve probably already seen a number—or a range—during your Googling around, it remains a surprisingly hard question to answer thoroughly. It’s funny how people’s minds often automatically go to “scrum” when they hear “agile.” However, let’s not forget there are many other methodologies and frameworks that live under the agile umbrella. It’s imperative to take their differences into account to answer the title question comprehensively. Another factor our discussion shouldn’t overlook is scale. Sure, most agile methodologies have been originally designed to help small teams. However, there are specific frameworks that cater to the needs of large organizations. We should certainly take them into account. Last but not least, we have to factor in the fact the people leave and join teams all the time. Isn’t agile about embracing and responding to change? How does it handle change to its own teams? All of those questions will be answered throughout the post. Let’s dig in. ## What Is the Recommended Size for an Agile Team? According to many experts on the matter, the recommended size for an agile team is about five to 11 people. OK, with the TL;DR out of the way, we’re free to discuss the issue in more depth. Why should you favor smaller teams? How do the different agile methodologies handle team size? And what about large-scale agile efforts? We’ll answer those questions and others now. ### Generally Speaking, Smaller Teams Are Better All else being equal, you should favor smaller teams over bigger ones. Why? It all boils down to _communication_. Every decision in software development has costs and benefits. This certainly applies to adding new members to a team. Sure, the team will—hopefully—benefit from the experience, knowledge, and perspectives the new member brings to the table. However, every new member in a team increases the communication overhead. Picture a team with two only two people, Aline and Bruno. There’s a single communication path, or relationship, happening. Now, a third member—say, Claudia—joins the team. Now, the existing communication paths increase to three. Then, a fourth member, David, joins the team. How many relationships now? Six. The number of possible relationships is given by the equation **n(n – 1)/2**, where **n** refers to the number of people that belong to the team. ### However, Agile Comes in Different Flavors The [scrum guide](https://scrumguides.org/scrum-guide.html) offers specific guidance regarding team size. However, there’s agile beyond scrum, though many people seem to forget that. Let’s now see what some of the main methodologies that fall under the umbrella of agile have to say about team size. #### What Is the Recommended Size for a Scrum Team? Scrum has always emphasized the importance of having a small, cross-functional, and self-managing team to create value during each sprint. How small is small, though? Here’s what the most recent version of the scrum guide says: > [The Scrum Team ](https://linearb.io/blog/how-to-improve-scrum-team-productivity/)is small enough to remain nimble and large enough to complete significant work within a Sprint, typically 10 or fewer people. #### What Is The Recommended Size For an XP Team? XP (extreme programming) also favors small teams, with the caveat of the “whole team” considered. “Whole team” is one of the practices of XP. It means that everyone whose skills are needed in the project should be part of the team. However, membership should be dynamic rather than permanent. For instance, under XP, it’d be okay for a DBA to leave the team once the most complex database modeling tasks are finished. As for exact numbers, different sources seem to agree that XP works better with teams from four to 12 people. Also, since pair-programming is a core practice of XP, keeping that team even-numbered is advised. #### What Is the Recommended Size for a Crystal Agile Team? The Crystal methodology has many characteristics that set it apart from most other agile methodologies. For starters, it isn’t a framework or a single methodology but a family of methodologies. Additionally, Crystal is unique among agile methodologies in that it acknowledges the necessity of handling different team sizes from the start. Each methodology inside the Crystal family is better suited to a particular scenario that considers several factors, which includes—you’ve guessed it!—team size. The following listing shows the recommended methodology for each team size: * Clear – teams up to eight people * Yellow – teams up to 20 people * Orange – teams from 20 to 50 people * Red – for larger teams up to about 100 people ### What About Agile at Scale? As we’ve mentioned, most agile methodologies favor small teams. The Crystal family of methodologies is an interesting exception since it prescribes different methodologies according to team size. However, we can’t ignore the fact that large enterprise organizations exist. Why shouldn’t they also be able to reap the benefits of agile? With that question in mind, groups have designed frameworks and methodologies to make agile work on a large scale. #### Team Size in SAFe The most famous of such efforts is probably the scaled agile framework, or simply SAFe®. Dean Leffingwell created SAFe with the first release in 2011\. It is a framework to help enterprises adopt and apply agile practices on a large scale. SAFe, similarly to scrum, is opinionated when it comes to team size. Its official page states that teams are groups of five to 11 people. It goes on to say that, due to communication overhead, organizations should favor collections of smaller teams over a single larger one. #### Team Size in LeSS Large-Scale Scrum, or [LeSS](https://less.works/), is a framework created in 2005 to help organizations apply scrum on a large scale. Teams in LeSS aren’t that different from regular scrum teams. They should be cross-functional, self-managing, long-lived, and co-located. As for team size, 10 should also be the upper limit. ## How to Handle Fluctuating Teams Developers routinely leave for greener pastures. If the organization isn’t doing that great financially, it might let some of its staff go. People retire, decide to switch careers, or pass away. On a less somber note, they might hit the lottery, and—hopefully—they take vacations regularly. How does agile account for such fluctuations? As it turns out, this is a [fairly common question](https://softwareengineering.stackexchange.com/questions/111767/what-should-i-do-if-scrum-member-leave-half-way) of newcomers to agile methodologies. The agile methodologies do offer ways to handle such changes. The vocabulary, of course, varies according to the specific methodology or framework. But the gist is this: If you lose a team member halfway through a cycle, that means your capacity—or budget—for work has been reduced. You handle that by renegotiating the scope for the current iteration with the product owner/customer, de-prioritizing the less critical stories. What if the opposite happens? Well, if a team gains one or more members halfway through a cycle, that means your capacity is now larger. It’s pretty hard to hit the ground running, and most new members will take a while until they’re able to start adding value to a project. However, as soon as they can contribute, their capacity has to be taken into account when doing the planning for the iteration. ## There’s More to an Effective Team Than Size This post discussed team size in agile and how it can affect the software development process. As you’ve seen, agile makes the case that large teams make communication more complex. All else being equal, you should favor smaller teams. However, if you’re interested in improving the [productivity](https://linearb.io/blog/engineering-productivity/) and efficiency of your dev team, there’s much more to consider than what a single number can tell you. You must ensure you’re tracking—and working to improve—important [signs about your team’s health](https://linearb.io/blog/dev-team-health/). You should foster diversity as well as the healthy conflict of ideas that ultimately arises from such diversity. Ultimately, you should encourage an environment that enables growth, continuous learning, and accountability. Do you have ideas to share related to this topic? Or maybe you have questions? You might want to check out [LinearB’s Discord community](https://discord.com/invite/wHvgytX9P7). [![Dev Interrupted. The New Faces of Engineering Leadership. Join us on Discord.](https://assets.linearb.io/uploads/discord-banner-1024x212.png)](https://discord.gg/devinterrupted) ## Improve developer productivity with LinearB Find us on [](https://www.linkedin.com/company/linearb) [](https://devinterrupted.substack.com/) ## Your next read [![Cover image for Code generation is faster than ever, but shipping value isn't](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_code_review_bottleneck_2400x1256_d73333ea46?_a=BAVMn6ID0)](https://linearb.io/blog/code-generation-faster-shipping-isnt) DevEx [Code generation is faster than ever, but shipping value isn't](https://linearb.io/blog/code-generation-faster-shipping-isnt) Your team writes more code than ever, but less reaches production. AI moved the bottleneck to code review. Here's how to measure it and unblock your pipeline.&n... [![Cover image for What to look for in an engineering productivity platform](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Developer_productivity_platform_2400x1256_0d47bff68e?_a=BAVMn6ID0)](https://linearb.io/blog/what-to-look-for-engineering-productivity-platform) DevEx [What to look for in an engineering productivity platform](https://linearb.io/blog/what-to-look-for-engineering-productivity-platform) AI made dashboards trivial, but the data foundation underneath still matters. How to evaluate an engineering productivity platform across four key outcomes. [![Cover image for Why OpenAI Codex builds the agent first, not the product](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Redefining_agentic_autonomy_2400x1256_98ff8e15fc?_a=BAVMn6ID0)](https://linearb.io/blog/openai-codex-thibault-sottiaux-agentic-autonomy) DevEx [Why OpenAI Codex builds the agent first, not the product](https://linearb.io/blog/openai-codex-thibault-sottiaux-agentic-autonomy) OpenAI’s Thibault Sottiaux reveals how the Codex team ruthlessly simplifies agent design by removing manual scaffolding, solving context compaction at the... ## Structured data _Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._ ```json { "@context": "https://schema.org", "@type": "Organization", "name": "LinearB", "url": "https://linearb.io", "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg", "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.", "sameAs": [ "https://www.linkedin.com/company/linearb" ], "award": [ { "@type": "Award", "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms", "dateAwarded": "2026", "awardedBy": { "@type": "Organization", "name": "Gartner®" } }, { "@type": "Award", "name": "Great Place to Work Certification", "dateAwarded": "2025-2027", "awardedBy": { "@type": "Organization", "name": "Great Place to Work" } }, { "@type": "Award", "name": "America's Best Startup Employers 2025", "dateAwarded": "2025", "awardedBy": { "@type": "Organization", "name": "Forbes Magazine" } } ], "hasCertification": [ { "@type": "Certification", "name": "SOC 1 Type 2" }, { "@type": "Certification", "name": "SOC 2 Type 2" }, { "@type": "Certification", "name": "GDPR Compliance certification" }, { "@type": "Certification", "name": "ISO 27001" } ] } ``` ```json { "@context": "https://schema.org", "@type": "Article", "headline": "What Is the Recommended Size of an Agile Team?", "url": "https://linearb.io/blog/what-is-the-recommended-size-of-an-agile-team", "author": { "@type": "Person", "name": "Carlos Schults" }, "datePublished": "2021-07-01T14:10:17.000Z", "dateModified": "2021-07-01T14:10:17.000Z", "image": "https://assets.linearb.io/image/upload/v1720000000/leon_Oalh2_Moj_Uuk_unsplash_scaled_ad4e2ebef4.jpg", "publisher": { "@type": "Organization", "name": "LinearB", "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png" }, "description": "What is the recommended size of an agile team? We’ll discuss how different agile methodologies handle this issue, and why team size matters.\n" } ``` ## More on linearb.io ### Top navigation - [Book a Demo](https://linearb.io/book-a-demo) - [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews) - [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights) - [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact) - [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server) - [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation) - [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization) - [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting) - [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance) - [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support) - [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience) - [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience) - [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys) - [Platform overview](https://linearb.io/platform/overview) - [Register now](https://linearb.io/event/engineering-productivity-gap) - [Customers](https://linearb.io/customers) - [Pricing](https://linearb.io/pricing) - [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb) - [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework) - [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq) - [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security) - [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy) - [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts) - [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources) - [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops) - [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report) - [Blog — Product updates and practical insights](https://linearb.io/blog) - [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io) - [API Docs](https://docs.linearb.io/api-overview) - [Status](https://www.linearbstatus.com/) - [Integrations](https://linearb.io/integrations) - [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026) - [Sign in](https://app.linearb.io/login) - [Enterprise](https://linearb.io/solutions/enterprise) - [Contact](https://linearb.io/contact-us) - [About us](https://linearb.io/about-us) - [Careers](https://linearb.io/careers) - [Service agreement](https://linearb.io/services-agreement) - [Privacy policy](https://linearb.io/privacy-policy) - [DPA](https://linearb.io/data-processing-agreement) - [Security FAQ](https://linearb.io/security-faq) - [Substack](https://devinterrupted.substack.com/) ### Footer _Additional links from the site footer, not repeated from the top navigation above._ - [GitHub](https://github.com/linear-b) - [LinkedIn](https://www.linkedin.com/company/linearb) - [Twitter](https://twitter.com/LinearB_Inc)