Autonomous AI Agents: your first working example

Why this example matters

Our toy workflow checks a list of planned actions. Reading public documentation and drafting a summary are allowed; deleting a repository pauses for explicit human approval.

What you will be able to do

• Recognize the input values and describe what they represent in Autonomous AI Agents.
• Run the Autonomous AI Agents program and explain why its displayed output follows from the recorded operations.
• Identify a limitation of the Autonomous AI Agents activity before applying similar reasoning to a real system.

Original worked program

The following Autonomous AI Agents demonstration uses small invented values so you can trace every operation. The Autonomous AI Agents activity uses only Python standard-library features; it downloads no model and calls no paid service.

planned_actions = ["read public docs", "write summary", "delete repository"]
requires_approval = {"delete repository"}
for action in planned_actions:
    status = "PAUSE FOR HUMAN" if action in requires_approval else "ALLOW"
    print(status, "-", action)

Actual output from Python

ALLOW - read public docs
ALLOW - write summary
PAUSE FOR HUMAN - delete repository

Read each instruction

1. planned_actions = ["read public docs", "write summary", "delete repository"]The assignment gives a name to a value or a calculated result in Autonomous AI Agents. In the Autonomous AI Agents activity, check the named values on that line rather than memorizing symbols.
2. requires_approval = {"delete repository"}The assignment gives a name to a value or a calculated result in Autonomous AI Agents. In the Autonomous AI Agents activity, check the named values on that line rather than memorizing symbols.
3. for action in planned_actions:The loop repeats an operation over the available values in Autonomous AI Agents. In the Autonomous AI Agents activity, check the named values on that line rather than memorizing symbols.
4. status = "PAUSE FOR HUMAN" if action in requires_approval else "ALLOW"The assignment gives a name to a value or a calculated result in Autonomous AI Agents. In the Autonomous AI Agents activity, check the named values on that line rather than memorizing symbols.

Observe the results

To verify the Autonomous AI Agents result, copy the program into a fresh file and run it once without modification. Then change only one input. For the Autonomous AI Agents trial, record what you predict before pressing Run again. Compare the Autonomous AI Agents prediction with the observed result.

Second original practice: Goal interpretation

The Autonomous AI Agents extension changes the task, not just the numbers in the first example. Study its new data structure or operation, then decide how the result supports the milestone “Goal interpretation”.

actions = ["read", "draft", "check", "publish"]
limit = 3
performed = actions[:limit]
print("Performed:", performed)
print("Paused before:", actions[limit])

Actual second output

Performed: ['read', 'draft', 'check']
Paused before: publish

For the Autonomous AI Agents extension, read the code from its first assignment or import to its final print statement. Explain the additional Autonomous AI Agents idea introduced by this extension, then design a check that could reveal a mistake. The Autonomous AI Agents extension output above was recorded by running that independent program.

What the example does not prove

A real agent must inspect each action and its arguments, not just a friendly task label. Persistent memory and scheduled tasks also need revocation and audit mechanisms.

A reliable Autonomous AI Agents project also needs an explicit objective, test cases that were not used to tune the approach, documentation of the assumptions, and review of situations where the result might mislead the user. Do not mistake the small Autonomous AI Agents program for evidence of accuracy or safety in a deployed application.

How to validate your own result

For Autonomous AI Agents, a convincing result starts with a written claim about the actual task, not the appearance of a successful print statement. For Autonomous AI Agents, list the initial values and the one value you will vary; record a prediction that could be disproved. Save both Autonomous AI Agents outputs as separate records to avoid mixing up the results of the two investigations. A correct Python run only establishes that the particular instructions executed; it does not establish that the assumptions match every situation in which Autonomous AI Agents might be used.

Connect this trial to “Task decomposition” without claiming that the milestone is already complete. Name a measurement you would collect for Autonomous AI Agents, a plausible error source and a person able to review the decision. The later topic “World-state tracking” deserves its own investigation with different evidence. Keeping these questions separate prevents your Autonomous AI Agents learning journal from becoming a collection of exercises that all make the same claim.

Finally, keep the Autonomous AI Agents experiment reproducible: include the Python version, exact script, input values, observed results and any unexpected behavior. If a Autonomous AI Agents investigation uses external data, document the source and your permission to use those records. A new learner should be able to explain every output line in ordinary words before moving into the next milestone of Autonomous AI Agents.

Second verified lab: Workflow in practice

To deepen Chapter 1 of Autonomous AI Agents, compare the first calculation with a different, executable experiment. The small workflow lab below illustrates a related technique, not every possible implementation of autonomy boundaries.

# Course: Autonomous AI Agents | Chapter 1 | Subject: Autonomy boundaries
# Least-privilege tool approvals with a step budget
allowed = {"inspect","summarize"}
requested = ["inspect","summarize","publish","inspect"]
step_limit = 2
executed=[]
for task in requested:
    if task not in allowed or len(executed)>=step_limit:
        print("Blocked:",task)
        continue
    executed.append(task)
print("Executed:",executed)
print("Count:",len(executed))

Actual output of the displayed code

Blocked: publish
Blocked: inspect
Executed: ['inspect', 'summarize']
Count: 2

While examining your first working example in the autonomous ai agents course (chapter 1), apply this test: Tool access is checked before each action and the step budget caps execution. The simulation leaves publishing unauthorized by design. For the repair shop delivery records exercise, distinguish what the code observes from any stronger predictive or causal claim.

While examining your first working example in the autonomous ai agents course (chapter 1), apply this test: Interpretation limit. A real agent also needs untrusted-input isolation, immutable logs, and user confirmation for consequential actions. Record the changed inputs and compare both outputs before extending the result to a project.Interpretation limit. A real agent also needs untrusted-input isolation, immutable logs, and user confirmation for consequential actions. Record the changed inputs and compare both outputs before extending the result to a project.

20 practice questions and worked answers

Test your understanding of your first working example in the autonomous ai agents course (chapter 1). Compare the claims in both runnable labs, and use the outputs to defend each numerical response.

Build one original mini-project

Chapter 1 checkpoint: Explain how autonomy boundaries affects the repair shop delivery records example; demonstrate one failing input; then propose a revision with an acceptance test and a recorded output. This checkpoint belongs to the Autonomous AI Agents course.

Create a three-step research workflow with a checkpoint before any action that changes a user account.

A six-step practice plan

1. Autonomy boundaries. For the “Autonomy boundaries” exercise, identify one observable result and record what would demonstrate progress in Autonomous AI Agents.
2. Goal interpretation. For the “Goal interpretation” exercise, identify one observable result and record what would demonstrate progress in Autonomous AI Agents.
3. Task decomposition. For the “Task decomposition” exercise, identify one observable result and record what would demonstrate progress in Autonomous AI Agents.
4. World-state tracking. For the “World-state tracking” exercise, identify one observable result and record what would demonstrate progress in Autonomous AI Agents.
5. Planning under uncertainty. For the “Planning under uncertainty” exercise, identify one observable result and record what would demonstrate progress in Autonomous AI Agents.
6. Tool permission scopes. For the “Tool permission scopes” exercise, identify one observable result and record what would demonstrate progress in Autonomous AI Agents.

Save your original inputs, your changed inputs, the two actual outputs and a short explanation of what you learned about Autonomous AI Agents. The Autonomous AI Agents record forms evidence for the first milestone of your project portfolio.

Where you go next

Your Autonomous AI Agents roadmap has 18 subject-specific milestones progressing toward evaluation and a capstone. Future Autonomous AI Agents lessons will require new demonstrations and evidence, beyond the skills taught in this first chapter.