Autonomy
Autonomy is the capacity or degree to make decisions and act independently within defined responsibilities and constraints.
Architecting for Autonomy
Autonomous decision-making power assigned to a system within explicitly defined limits, conditions, and accountability requirements.
- How it is used
- Frames autonomy as delegated enterprise decision authority that must be supervised at runtime.
- How deep it goes
- Defines bounded autonomy and elaborates ownership, observation, runtime controls, and escalation through architectural principles and examples.
- Examples
- Uses a bank fraud agent that freezes accounts and a threshold requiring human approval for larger interventions.
- What you can do after
- Evaluate and understand delegated autonomy by identifying decision boundaries, accountable roles, runtime controls, and escalation conditions.
Effective Platform Engineering
Autonomy is the ability of developers or teams to work and make decisions independently within their responsibilities.
- How it is used
- Reduces delivery friction by giving teams control of their work within governance and compliance guardrails.
- How deep it goes
- Works through a pipeline pattern that separates compliance work from deployment-time verification, while naming other autonomy opportunities without detailing them.
- Examples
- Uses delayed infrastructure requests, a self-service microservice deployment, and process mapping with delivery metrics.
- What you can do after
- Practice/perform it by identifying handoffs, returning pipeline control to teams, and placing compliance verification at deployment.
Microservices Patterns, Second Edition
Team autonomy is a team property in which the team can perform its work with minimal dependence on coordination, hand-offs, or waiting on other teams.
- How it is used
- Uses team autonomy as an architectural requirement for fast flow and reduced coordination.
- How deep it goes
- Defines autonomy, explains its architectural conditions, and compares how monoliths and microservices support it as organizations grow.
- Examples
- Illustrates autonomy with order and customer management teams and a monolith facing widespread API, library, or runtime changes.
- What you can do after
- Evaluate architecture choices for their effects on team coordination and independent delivery.
Read how Microservices Patterns, Second Edition explains autonomy →
AI Agents in Action, Second Edition
Autonomy is the capacity of a system to select and perform actions without requiring a separate user decision for each step.
- How it is used
- Distinguishes goal-directed agents from assistants by their ability to continue multistep work without user decisions between steps.
- How deep it goes
- Explains the tool-observation-decision loop and outlines layered safeguards against cascading errors and runaway execution.
- Examples
- Compares direct chat, tool-augmented models, assistants, and agents using research, image generation, and browser automation as use cases.
- What you can do after
- Evaluate/understand an agent’s autonomy by examining its decision loop, approval boundaries, and safeguards.
Read how AI Agents in Action, Second Edition explains autonomy →
AI Governance
The degree to which an AI system can pursue goals and take actions without direct human intervention.
- How it is used
- Frames autonomous action as an ethical risk that grows with tool access and workflow reach.
- How deep it goes
- Defines impact-based autonomy tiers and describes classification, enforcement, and review procedures.
- Examples
- Uses a credential workaround and contrasts unattended data reads with production edits and payroll actions.
- What you can do after
- Configure autonomy tiers and workflow checkpoints based on action impact and human accountability.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
The ability of a product, team, or organizational unit to make decisions and operate independently.
- How it is used
- Uses autonomy to distribute architectural and product decisions while balancing team independence with coordination and standardization.
- How deep it goes
- Defines nine mandate levels and their trade-offs, but stops short of treating mandate authority as the whole of value-stream independence.
- Examples
- Illustrates autonomy through Salesforce product groups, OpenTable teams, and mandate levels ranging from predetermined specifications to business outcomes.
- What you can do after
- Evaluate team independence with mandate levels and compare organizational designs against coordination, duplication, consistency, and flow outcomes.
Think Like a Software Engineering Manager
Autonomy is the capacity of an individual or team to make decisions and act without continuous direction from a leader.
- How it is used
- Uses autonomy to develop experienced engineers, delegate decisions, empower teams, and support flexible workload management.
- How deep it goes
- Explains autonomy through delegation, experience-based support, expectations, check-ins, training, feedback, and flexibility, without detailing implementation mechanics.
- Examples
- Uses configuration-management ownership, flexible working hours, core-hours policy revision, and delegated backend load-testing strategy as practical examples.
- What you can do after
- Practice/perform autonomy by delegating outcomes, setting expectations, checking progress, supplying support, and adapting to feedback.
Read how Think Like a Software Engineering Manager explains autonomy →
Build an AI Agent (From Scratch)
Autonomy is the capacity of a system to determine and continue its own actions without a predetermined sequence controlling every step.
- How it is used
- Guides agents to act on clear user intent and continue tool-mediated work without unnecessary confirmation.
- How deep it goes
- Explains the assess–act–observe–repeat loop and prompt-level ambiguity handling, but does not provide implementation code.
- Examples
- Uses weather search, calculations, file analysis, multistep research, and generated parsing functions as autonomy examples.
- What you can do after
- Configure agents to select tools, execute clear requests, ask minimal clarifying questions, and continue until completion.
Read how Build an AI Agent (From Scratch) explains autonomy →
Lead Developer Career Guide
The ability and authority to act, make decisions, and solve problems independently.
- How it is used
- Develops mentees who can own work, make decisions, and solve problems without constant instruction.
- How deep it goes
- Details gradual delegation, guided reasoning, and calibrated support, while stopping short of a formal autonomy framework.
- Examples
- Uses a mentee overwhelmed by answers and recommends conferences, workshops, or open-source contributions as growth opportunities.
- What you can do after
- Apply mentoring tactics that transfer responsibility while preserving guidance and support.
Collaborative Software Design: How to facilitate domain modeling decisions
Autonomy is the ability of a team to make decisions and progress independently without requiring continual alignment or approval from other teams.
- How it is used
- Frames autonomy as a way to assess whether teams can develop independently in a microservices transition.
- How deep it goes
- Defines autonomy through a shared-kernel scenario and shows how synchronization reduces it, without detailing alternative architectures.
- Examples
- Uses four teams, a monolithic application, separately owned bounded contexts, and a shared model as the concrete example.
- What you can do after
- Evaluate how shared models and required coordination constrain independent team progress.
Build High Value Software Systems
Control over how one works and the ability to exercise judgment in defining and solving problems.
- How it is used
- Frames autonomy as a way to give developers judgment when defining problems and using AI to explore solutions.
- How deep it goes
- Defines autonomy through problem ownership and contrasts open-ended problem statements with externally prescribed solutions.
- Examples
- Uses flexible date filtering to contrast a user problem with a three-option dropdown specification and corresponding AI prompts.
- What you can do after
- Evaluate AI-generated solutions critically by framing the user problem before specifying an implementation.
Read how Build High Value Software Systems explains autonomy →
Software Testing with Generative AI
The capacity of a software system to select and perform actions toward a goal without an explicitly ordered sequence being prescribed for every action.
- How it is used
- Explains how AI agents choose and sequence actions while solving complex testing-related tasks.
- How deep it goes
- Defines autonomy through goals, interaction, function selection, and feedback, but does not specify implementation code.
- Examples
- Uses web APIs, web scraping, booking-form automation, sensors, and selective function sequences as concrete examples.
- What you can do after
- Evaluate/understand how an agent differs from a tool executing a fixed, ordered list of functions.
Read how Software Testing with Generative AI explains autonomy →
Think Like a CTO
Autonomy is the authority of a person or team to make decisions and handle work independently within defined boundaries.
- How it is used
- Coordinates autonomous teams through reporting mechanisms that preserve independence while keeping leaders informed of progress and issues.
- How deep it goes
- Defines autonomy through three decision buckets and communication expectations, but stops short of universal thresholds.
- Examples
- Uses client disaffection, security concerns, production problems, hiring, tool purchases, and the no-update update.
- What you can do after
- Operate team autonomy through shared rules, escalation triggers, and timed status updates.
Vibe Engineering
Autonomy is the degree to which a software system can select and carry out actions without direct human intervention.
- How it is used
- Uses autonomy as the scaling variable for moving from developer sessions toward unattended software workflows.
- How deep it goes
- Distinguishes interfaces from approval levels and adds operational guardrails, but stops short of specifying an autonomy measurement system.
- Examples
- Uses terminal agents, IDE background agents, cron, hooks, pipelines, and multi-agent feature workflows as concrete cases.
- What you can do after
- Evaluate autonomy choices by workflow predictability, approval needs, observability, and rollback readiness.
Also covered in
- Evaluating AI SystemsIn early access (MEAP)
- Delivering Machine Learning Projects: From design to deployment
- Introduction to Generative AI, Second Edition
- Inside AI
- Knowledge Graphs and LLMs in Action
- AI Agents for Offensive SecurityIn early access (MEAP)
- Digital Twins in Action
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- AI agentAn AI agent is a computational system that uses artificial intelligence to interpret information and select or perform actions toward goals while interacting with an environment.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- human-in-the-loopHuman-in-the-loop is a system or workflow design in which people participate in reviewing, guiding, correcting, or authorizing an automated process.
Related concepts
- microservice architectureproduced by · Microservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- intrinsic motivationpart of · Intrinsic motivation is motivation arising from interest, enjoyment, satisfaction, or challenge inherent in an activity rather than from external rewards or pressures.
- human-in-the-loopcontrasts with · Human-in-the-loop is a system or workflow design in which people participate in reviewing, guiding, correcting, or authorizing an automated process.
- automationcontrasts with · Automation is the execution of tasks or processes by machines or software with reduced direct human intervention.
- autonomy boundaryconfigured by · A defined limit separating conditions under which an autonomous system may act from conditions requiring escalation, further scrutiny, or another control path.
- loose couplingproduced by · A design property in which components have limited direct dependencies and can change or operate more independently of one another.
Questions about autonomy
What is autonomy?
Autonomy is the capacity or degree to make decisions and act independently within defined responsibilities and constraints.
Which Manning books explain autonomy?
Architecting for Autonomy, Effective Platform Engineering, Microservices Patterns, Second Edition, AI Agents in Action, Second Edition, AI Governance, Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Think Like a Software Engineering Manager, Build an AI Agent (From Scratch) and 6 more.
What should I know before learning autonomy?
Manning books that teach autonomy usually introduce language model, AI agent, deployment pipeline and human-in-the-loop first.
What is the difference between autonomy and human-in-the-loop?
Autonomy is the capacity or degree to make decisions and act independently within defined responsibilities and constraints. Human-in-the-loop is a system or workflow design in which people participate in reviewing, guiding, correcting, or authorizing an automated process.
What is autonomy part of?
Autonomy is part of intrinsic motivation. Intrinsic motivation is motivation arising from interest, enjoyment, satisfaction, or challenge inherent in an activity rather than from external rewards or pressures.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.













