Autonomy in AI Agents:
Concepts and Practice

How Definitions Evolved

2023

“AI systems that can pursue complex goals with limited direct supervision.”

Shavit et al. 2023

“AI agents are artificial entities that sense their environment, make decisions, and take actions.”

Xi et al. 2023

2024

“…an application that attempts to achieve a goal by observing the world and acting upon it using the tools that it has at its disposal.”

Wiesinger et al. 2024

Agents are systems where “LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.”

Anthropic 2024

2025

“Agents are systems that independently accomplish tasks on your behalf.”

OpenAI 2025

“Systems of multiple AI agents collaborating to achieve complex goals.”

Sapkota et al. 2025

What Makes an Agent

Characteristics what an agent does

Autonomy

Operates without direct human intervention and controls its own actions: the LLM directs its own process and tool use.

Wooldridge & Jennings 1995 · Anthropic 2024

Goal-directed

Takes the initiative toward a goal instead of only reacting, and accomplishes the task on the user's behalf.

Wooldridge & Jennings 1995 · OpenAI 2025

Perceives its environment

Senses the environment and responds to changes; each step brings ground truth, such as tool results or code output.

Wooldridge & Jennings 1995 · Anthropic 2024

Social ability

Interacts with other agents and humans: delegates, collaborates, hands off, and returns control when it cannot finish.

Wooldridge & Jennings 1995 · Tomašev et al. 2026 · OpenAI 2025

Reasons and plans

Interleaves reasoning with acting, breaks tasks into steps, reflects on past actions and corrects course.

Yao et al. 2022 · Weng 2023

Acts through tools

Uses tools to gather context and to take actions, choosing the right one for the current state of the workflow.

OpenAI 2025 · Schick et al. 2023

Building blocks what an agent is made of

An agent is an LLM that reasons and decides, guided by instructions and memory, acting on its environment and on other agents through tools, all inside guardrails.

Two bands. Top: what an agent does. Bottom: what it is made of.

Characteristics. Start with autonomy, the topic of the talk: it controls its own actions. Then goal-directed, perceives its environment, social ability, reasons and plans, acts through tools. The first four trace back to Wooldridge and Jennings in 1995, which shows the idea is old and the LLM is what changed.

Building blocks. Walk the diagram: the LLM reasons and decides. Instructions and context guide it. Tools let it read, act and delegate. The environment returns ground truth after each step. Session and memory live outside the model. Guardrails wrap everything.

The dashed box is the harness: the loop around the model. Hover it for the definition and the sources I followed.

Takeaway: an agent is an LLM that reasons and decides, acts through tools on its environment and on other agents, all inside guardrails.

AgentStudio

About AgentStudio

AgentStudio is a desktop app where you draw a multi-agent workflow on a canvas instead of writing code. Agent, Tool, Trigger and Condition nodes are joined by edges, and the drawing is itself the runnable definition. It runs on the Claude Agent SDK and OpenAI Agents, with tools from MCP servers, and a CLI and cron or webhook triggers let it run unattended. Its own repository became its first workload: agents triage, build, validate, review and merge the changes to the app that runs them, as a test of autonomy on a real, growing codebase.

The first version of AgentStudio: a node palette, a canvas and an inspector — **12 May 2026, day 1.** Four node types, a canvas and an inspector. The workflow shown was drawn for this screenshot.

AgentStudio today: the AgentStudio workflow, with an hourly repository audit and a five-minute issue intake, analyst, implementer and reviewer chain — **Today.** The workflow that maintains AgentStudio: an hourly repository audit, and an issue chain of intake, analyst, implementer and reviewer.

AgentStudio Built Itself

The loop an app that builds agent workflows, run by agent workflows

Every change to AgentStudio starts as a GitHub issue. One workflow claims it, an author agent builds it on its own branch, four validators check the pull request in parallel, and a reviewer agent approves or sends it back for a bounded fix loop. On approval it merges itself. Anything an agent finds outside its task becomes a new issue, so the loop feeds itself.

How it grew

12 May · Day 1

Built by hand with Claude

Canvas with Agent, Tool, Trigger, Condition nodes, inspector, SQLite, encrypted secrets
149 commits in one day; 63 TypeScript files

13 May

Gets hands: CLI and cron

Headless CLI and a cron scheduler, so workflows can run unattended
Issue 1 is a CLI feature; CLAUDE.md sets the agent rules

15 May

Closes the loop

Autonomy 1/4 to 4/4 (issues 559 to 562): PR tools, Reviewer agent, PR Validators with auto-merge, bounded fixer loop

10 to 23 Jul

Runs at scale

Numbered waves of work: approval gate, webhook trigger, OTLP tracing, crash-safe runs
1,153 TypeScript files in src

1,618 commits920 merged PRs1,468 issues21 days with commits

Every change starts as a GitHub issue. Walk the loop: the issue reviewer claims it, the author builds on its own branch, four validators check the pull request in parallel, the reviewer approves or sends it back for a bounded fix loop, then it merges itself.

The detail I like: anything an agent finds outside its task becomes a new issue. The loop feeds itself.

Timeline. Day 1 (12 May) built by hand with Claude. 13 May: CLI and cron, so it runs unattended. 15 May: the loop closes with reviewer, validators and auto-merge. July: it runs at scale in numbered waves.

Numbers, read from GitHub on 13 Oct 2026: 1,618 commits, 920 merged PRs, 1,468 issues, over 21 days with commits.

Say plainly: this is one project and one developer's experience, not a benchmark. Hover a box for what each step really is.

How Agents Are Given Autonomy

Spawns its own agents
Before, developers fixed the roles and the number of agents in advance. Now a lead agent decides how many subagents the task needs and launches them in parallel. The latest systems let peer agents claim tasks and message each other, with no central orchestrator.
Anthropic 2024 · Hadfield et al. 2025 · Carlini 2026
Builds its own tools
Before, developers wrote a fixed list of tools. Now the agent writes code to act, creates the tool a task needs and saves it for reuse. It can even evolve its own scaffold while it works.
Anthropic 2024 · Xia et al. 2025 · Jones & Kelly 2025
Acts on its environment
Before, agents could only use the calls developers had wired in. Now they run code in their own sandbox, with many tasks in parallel. They can also operate a computer like a person: look at the screen, click and type.
Anthropic 2024 · OpenAI 2025 · Claude blog 2026
Works out what is needed
Instead of waiting for a full specification, the agent expands a short request into a detailed plan. It asks clarifying questions when the task is complex. It tests the running result itself rather than trusting its own report.
Rajasekaran 2026 · Anthropic 2026
Checks its own work
Models tend to praise their own output. So a separate evaluator agent reviews what the generator built. Keeping the doer and the judge apart is a strong lever for quality.
Rajasekaran 2026
Is supervised less
People used to approve every action. With experience they switch to auto-approve and watch, stepping in only when needed. Auto-approve grows from about 20% to over 40% of sessions.
Anthropic 2026

Final slide: how do agents get autonomy? Six shifts, each "before" and "now".

Spawns its own agents: from fixed roles to a lead agent deciding how many subagents to launch, and peers messaging each other.

Builds its own tools: from a fixed tool list to writing code and saving the tool it needed.

Acts on its environment: runs code in a sandbox, even operates a computer like a person.

Works out what is needed: expands a short request into a plan, asks clarifying questions, tests the result itself.

Checks its own work: models praise their own output, so a separate evaluator agent judges it.

Is supervised less: people move to auto-approve and watch. Auto-approve grows from about 20% to over 40% of sessions (Anthropic 2026).

Closing: autonomy is granted step by step as trust and tooling grow. Questions?