There are five levels of autonomy. The level of autonomy expresses the level of ability for components of the distributed system to both evolve and connect independently.
Level 1: Brittle System
Tightly coupled components, No semantics, interface, or lifecycle metadata. Fast time to delivery for point to point integrations when complexity is low.
Everything breaks when something changes—not scaling with growing complexity.
Example: Any undocumented API, usually backend-for-frontend APIs.
Level 2: Documented System
Tightly coupled components. Interface metadata available. Human only-semantics metadata is available. No lifecycle metadata (is the documentation documenting the interface implementation?).
Possible productization. Reusability. Lock-on changes, unable to evolve independently.
Example: Most of the APIs documented using an API description (API Blueprint, OpenAPI Specification, GraphQL Schema, Avro Schema, Protocol Buffers ...).
Level 3: Automated System
Mostly tightly coupled components. Metadata are verified, valid, and reliable. Metadata are human or machine-readable. Explicit understanding of price and risk of making changes in the API landscape. Quality Control.
Advanced mindset change involving many people is needed. Often meets cultural denial, hard to get buy-in.
Example: Automated Contract-driven API Lifecycle.
Level 4: Decoupled System
Uniform Interface. Decoupled components. Evolvability of the components in their respective environments. Advertisement of the interface, semantics, and lifecycle metadata. Shared understanding-metadata at runtime. Client subscription to future changes. Harmonized within the system. Reducing price and risk of making changes (by design).
No machine autonomy. Complicated taking everything into account, prone to chaotic & size complexity.
Example: Automated Contract-driven API Lifecycle with 100% of REST APIs (incuding HATEOAS—Unifrom Interface subconstraint).
Level 5: Autonomous System
Self-driving clients, landscape discovery, machine understanding, vocabulary over the data structure, declarative programming, autonomy of the components. Leveraging learned data from simulation for infrastructure. The higher level of abstraction. Implicit harmonization. Full autonomy of components. Independent evolution.
High cognitive (Algorithmic) Complexity. Demanding on computational power.