Agile’s history is a transition from rigid, manufacturing-based “Waterfall” models to flexible, people-centric frameworks. While the term was coined in 2001, its roots trace back to early 20th-century industrial practices and the “software crisis” of the 1960s. 

Early Foundations (Pre-1990s)

Before Agile became a formal software methodology, its core principles of efficiency and iteration emerged from manufacturing and early computing.

• 1896: Sakichi Toyota introduced the “Stop and Notify” concept (Jidoka), a foundational Lean/Agile practice for immediate problem-solving.
• 1948: The Toyota Production System (TPS) established Lean manufacturing and the Kanban system to manage workflow.
• 1957: IBM began using incremental development on large software projects.
• 1970: Winston Royce published “Managing the Development of Large Software Systems,” which formalized the Waterfall Model but actually cautioned against its rigidity.
• 1986: Takeuchi and Nonaka published The New New Product Development Game, introducing the “rugby” metaphor for team-based development that inspired Scrum. 

The Rise of “Lightweight” Methods (1990–2000) 

Frustrated by Waterfall’s slow delivery, practitioners developed several “lightweight” frameworks. 

• 1991: Rapid Application Development (RAD) popularized timeboxing and iterations.
• 1993: Jeff Sutherland and his team first implemented Scrum at Easel Corporation.
• 1994: The Dynamic Systems Development Method (DSDM) was created as a vendor-independent RAD framework.
• 1995: Ken Schwaber and Jeff Sutherland formally co-presented Scrum at the OOPSLA conference.
• 1996: Kent Beck introduced Extreme Programming (XP), emphasizing practices like pair programming and continuous testing.
• 1997: Feature-Driven Development (FDD) and Crystal Clear emerged as alternative iterative models. 

Formalisation & Modern Evolution (2001–Present)

The movement unified under a single name and eventually scaled to entire enterprises. 

• 2001: 17 software leaders met at Snowbird, Utah, to draft the Agile Manifesto, establishing four core values and 12 principles.
• 2003: The book Lean Software Development by Mary and Tom Poppendieck officially bridged Lean manufacturing and software agility.
• 2009: The concept of DevOps emerged, extending Agile principles into IT operations and deployment.
• 2011: The Scaled Agile Framework (SAFe) was introduced to help large organizations manage multiple Agile teams.
• 2012–2015: Agile surpassed the 50% mark in global adoption, becoming the industry standard for development.
• 2020s: Agile principles are now widely applied outside of tech, in fields like marketing, education, and HR. 

Agile’s evolution is not just a 21st-century phenomenon but a response to decades of “software crises” and rigid industrial processes. Below is a comprehensive historical breakdown of Agile’s journey. 

1. Pre-Digital Foundations (1910s – 1940s)

Long before software, the concepts of efficiency and waste reduction were born in manufacturing. 

• 1911: Scientific Management. Frederick Taylor encouraged managers to adopt worker suggestions for efficiency, opposing rigid habits.
• 1940s: Lean Manufacturing (Toyota). Toyota pioneered the “Just-in-Time” method and Kaizen (continuous improvement) after observing American supermarkets.
• 1948: Toyota Production System. Introduction of Kanban for visual workflow management. 

2. Early Iterative Development (1950s – 1970s)

The 1950s saw the first departures from strictly sequential “waterfall” planning. 

• 1957: Incremental Development. IBM and Motorola teams, including Gerald Weinberg, used iterative methods indistinguishable from modern Extreme Programming (XP) for Project Mercury.
• 1968: NATO Software Engineering Conference. Formally identified the “Software Crisis” (projects being late and over budget), sparking a search for better methodologies.
• 1970: Waterfall Formalised (and Critiqued). Winston Royce described the Waterfall model but notably advocated for iterative releases to reduce risk. 

3. The Proliferation of “Lightweight” Methods (1980s – 1990s) 

Frustration with heavyweight, document-heavy processes led to several “Agile” precursors. 

• 1986: “The New New Product Development Game.” Takeuchi and Nonaka published this HBR article, introducing the “Rugby” approach (teamwork over relay-race handoffs), which directly inspired Scrum.
• 1991: Rapid Application Development (RAD). James Martin introduced RAD, emphasising fast prototyping and client feedback.
• 1993–1995: The Birth of Scrum. Jeff Sutherland and Ken Schwaber formalised Scrum, presenting it at the OOPSLA ’95 conference.
• 1996: Extreme Programming (XP). Kent Beck introduced XP at Chrysler, focusing on technical excellence through practices like Pair Programming and Test-Driven Development. 

4. The Agile Manifesto & Formalisation (2001 – 2010)

Agile moved from a collection of “lightweight” methods to a global standard. 

• 2001: The Agile Manifesto. 17 developers met in Snowbird, Utah, to draft the Manifesto for Agile Software Development, establishing four core values and 12 principles.
• 2003: Lean Software Development. Mary and Tom Poppendieck adapted Toyota’s Lean principles specifically for software engineering.
• 2009: Software Craftsmanship. The Software Craftsmanship Manifesto emerged to refocus the community on the quality of the “craft” rather than just project management.
• 2010: The First Scrum Guide. Published as the definitive resource on Scrum framework rules. 

5. Scaling and Modern Business Agility (2011 – Present) 

Agile expanded beyond coding into enterprise-wide strategy. 

• 2011: Scaled Agile Framework (SAFe). Dean Leffingwell launched SAFe to help large corporations apply Agile at scale.
• 2015–2017: Project Management Integration. Major bodies like AXELOS released PRINCE2 Agile, and the PMI introduced the Agile Certified Practitioner (ACP).
• 2020s: Beyond Software. Agile principles are now standard in marketing, HR, and hardware development through concepts like Business Agility.