7 Days Certified AI Agents with Python: Autonomous Apps

Understand the agent loop — observe, decide, and act — and build a stateful Python loop with a maximum number of steps, stopping rules, and clear iteration traces.

Compare deterministic and autonomous workflows using the observe-think-act model in a hybrid Python workflow. Place autonomy where it adds value, while deterministic code handles validation and safety.

Define a system prompt and persona that establish the assistant's role, objectives, rules, boundaries, and output structure, guiding behavior with the observe-think-act model toward concise, actionable responses.

Connect python to an llm via a provider-agnostic messages flow, implement a single model client with error handling and logging, and validate structured outputs.

Learn to build structured agent responses with a defined schema, using Pydantic to validate fields like message, action, priority, and needs clarification, enabling a reliable observe-think-act model.

Explore common agent failure patterns and design for recovery using observe-think-act, with safeguards like schema validation, tool validation, and clear error traces to build robust autonomous apps.

Demonstrates building a local conversational personal ai assistant with Python, olama, streamlet, pydantic, pymu pdf, and SQLite; runs on localhost:8501 and supports chat, summarize, task list, and draft email.

Turn broad goals into structured plans, validate and approve them, and build a reliable ai task planning agent in Python using Pydantic models and JSON.

Learn how planning clarifies goals, creates a plan and check, and encodes tasks, dependencies, and success criteria into a Python data structure for reliable, multi-step execution.

Explore task decomposition to break large objectives into bounded, verifiable tasks for AI agents, using goal, plan, check, and a Python task graph with clear inputs, outputs, and completion criteria.

Explore how to separate planning, execution, and review in a planner-executor architecture, enabling clear boundaries, traceable state, and testable goals, plans, and checks.

Explore react-style reasoning, an observable control loop where an agent alternates deciding, acting, observing, and updating the goal-plan-check cycle within bounded steps, using tools and user interactions.

Learn reflection and self-correction by evaluating outputs against goals, rubrics, and constraints, and use a structured review loop with a Python reviewer to pass, revise, or escalate.

Learn decision trees and routing to guide an autonomous agent through clear, testable paths using deterministic rules or model-based routing with classifiers.

Learn to define and validate a structured plan with Pydantic, enforcing a strict task schema (id, title, priority, dependencies, status) through shape, validation, and repair.

Master how to use Python and Pydantic to parse, shape, validate, and repair JSON-based data, enforcing structured output and a clean boundary between raw text and validated objects.

Validate model output beyond parsing and types; JSON can be structurally valid yet semantically wrong. Distinguish structural, semantic, and business validation with shape, validate, repair, and Python checks.

Repair the contract: detect malformed outputs, explain validation error, and request a corrected response within a limited retry policy, preserving observability with logs of the raw invalid output and error.

Participate in hands-on lab 2 to explore an AI task planning agent using Python for autonomous apps.

Demonstrates setting up and running the ai task planning agent demo, including starting the olama server, creating a virtual environment, and launching the streamlet app. Generate, revise, and approve a draft plan with constraints and track task status in a practical workflow.

Learn to build tool-using productivity agents that select tools, prepare arguments, execute Python functions and external services, and log decisions with permissions.

Map approved tool requests to the correct implementation and policy in Python-powered agents. Use a three-stage router (input, decision, output) with a registry and policy layer.

Learn how to convert raw tool results into a common, structured envelope that shows success and provides only data needed as evidence for the next model decision.

Design reusable Python tools by separating core logic from adapters, enforcing typed inputs and predictable outputs, and testing with unit tests, dependency injection, and tool registration for reliable agent apps.

Learn to wrap rest apis with a Python wrapper that handles endpoints, http methods, authentication, timeouts, status code handling, and response normalization, while managing errors and exposing a read-only tool.

Explore error handling and retries by distinguishing temporary from permanent failures, implementing max retries with exponential backoff, ensuring idempotent writes and graceful user-facing recovery.

Explore tool permissions and security by enforcing least privilege, separating capabilities by risk, and using a policy layer to verify user context and approvals before tool execution.

Implement an input decision output workflow with an approval gate to pause risky actions, clearly present proposed effects, and require target-specific confirmation to prevent unauthorized actions and prompt injection.

Design sequential and parallel tool execution by organizing calls with dependencies, using explicit call_id and depends_on labeling, and grouping independent tasks for concurrency.

Watch a tool-using productivity agent demonstrate how it leverages calculator, weather lookups, web search, and data tools in a Streamlit interface to automate tasks and save results.

Discover how to build a memory-enabled document assistant with selective short- and long-term memory, embeddings, a vector database, and retrieval augmented generation for evidence with citations.

Discover why memory must be selective and linked to a use case, separating user memory from document knowledge to enable continuity without overhead, using a store-retrieve-ground memory workflow.

Explore episodic, semantic, and procedural memory in a memory-enabled document assistant by classifying events, facts, and procedures, and grounding retrieved results with type and source.

Explore conversation memory concepts to maintain continuity while managing growth, separating user memory from document knowledge, and implementing a rolling context package with SQLite tables.

Explore embeddings and vector databases to enable semantic search across documents by numerically representing content and performing nearest-neighbor retrieval with metadata.

Chunk documents into meaningful passages so they can be embedded and retrieved independently; store, retrieve, and ground at the chunk level for a memory-enabled document assistant.

Explore semantic search concepts, distinguish semantic similarity from keyword search, and practice retrieval loops, embeddings, evaluation, and source-labeled grounding in a memory-enabled document assistant.

Explore how retrieval augmented generation combines document retrieval with language generation to produce evidence-based answers, using the rage pipeline: store, retrieve, ground.

Master context window management by prioritizing relevant context within a prompt budget, using inputs like system prompts, recent turns, memories, and document chunks to assemble a final context package.

Connect claims to inspectable source passages, attach stable citations, trace information flow, and translate ideas into a memory-enabled document assistant powered by the Python component.

Learn to prevent irrelevant memory in memory-enabled agents by deduplicating, scoping, and expiring records, separating user memory from document knowledge, and validating memory through a structured retrieval pipeline.

Explore user-controlled memory in a memory-enabled document assistant, making memory visible, editable, deletable, and durable only with consent and clear ownership.

Develop a memory-enabled document assistant using Python in a hands-on lab, exploring autonomous AI agents and practical app workflows.

Demo shows a memory-enabled document assistant that runs via a bash script to set up a Streamlit app, ingest pdfs, and query with long-term memory.

Define autonomous, bounded research agents that break questions into focused searches, collect and verify sources, remove duplicates, and generate a cited report with stopping conditions and human review.

Explore how an autonomous agent operates within a controlled loop of observe, decide, act, and check, with limits, budgets, and escalation rules.

Turn broad questions into focused search queries by defining the idea, mapping to the research workflow, and building a Python component for an autonomous agent, with exploratory and verification queries.

Design a deliberate search strategy that moves from explore to narrow to verify, and translate it into a Python component for an autonomous research agent with diverse sources.

Design and implement a source collection workflow for autonomous research agent in Python, capturing provenance, applying discover, reserve, and preserve steps, and modeling sources with robust records and failure testing.

Learn to transform long source content into structured findings through information extraction, capturing source, claim, evidence, and supporting passages for an autonomous research agent using a Python component.

Assess source reliability using explicit criteria—authority, relevance, recency, transparency—applied to a research workflow, translating into a Python component for autonomous agents.

Test claims against independent or primary evidence before inclusion, connect to the research workflow, and implement a Python component for an autonomous research agent using Claim, Corroborate, and Resolve.

Learn how to define stopping conditions for autonomous research agents in Python, including when to stop, continue, or request human guidance, with tests and reporting.

Examine reflection and gap analysis to align objectives with evidence, translate concepts into a Python component for autonomous agents, and produce a prioritized gap list for the final report.

Learn to turn verified evidence into a concise, structured report for an autonomous research agent, including an evidence package, outline, and audience-tailored sections like executive summary and key findings.

Develop and test an autonomous research agent using Python in a hands-on lab setting, exploring practical techniques for building autonomous apps.

This demo runs an autonomous research agent that uses filters and autonomous loops to fetch webpages, producing a final report with an executive summary, sources, and a workflow trace.

Design narrow, non-overlapping agent roles—researcher, analyst, writer, and reviewer—with explicit contracts, detailing inputs, state, decisions, and handoffs, implemented as Python components or Langraph rules for a transparent workflow.

Define and implement the planner-executor-reviewer architecture to separate design, production, and evaluation. Use plan-execute-evaluate with explicit contracts, routing rules, visible records, and revision controls for multi-agent workflows.

Adopt a supervisor architecture with a central coordinator that inspects the shared state, routes to the next agent, and enforces allowed transitions and stop conditions in a multi-agent workflow.

Explore sequential workflows that run one stage after another with validation checkpoints between stages, guiding planner, researcher, analyst, writer, and reviewer through validated handoffs.

Design parallel workflows with independent agents, split work, run concurrently, and merge outputs with provenance-preserving reducers across technical, business, and risk branches.

Design concise, structured agent communication that defines inputs, state, decisions, and handoffs, translating ideas into Python components or Langraph rules, with intent, payload, and context guiding each message.

Explore message passing in multi-agent systems, defining sender, contract, and receiver roles for auditable handoffs. Develop validated pipelines with message factories, logs, and receiver-side checks to ensure secure, traceable workflows.

Learn to resolve conflicts in multi-agent systems with detect, compare, and decide workflows, and build a conflict record model with routing policies for resolution.

Learn when to share or isolate information across a multi-agent system by managing global, local, and retrieved memory with privacy and role-based access controls.

Explore multi-agent failure patterns and design observable, fault-tolerant workflows with contracts, retries, fallbacks, checkpoints, and clear detect-contain-recover strategies across agent handoffs.

Explore Lang Graph to model a multi-agent workflow as a stateful graph with explicit routing, checkpoints, and roles like planner, researcher, analyst, writer, reviewer, and supervisor.

Join a hands-on lab that demonstrates a multi-agent content and analysis workflow, coordinating autonomous agents within Python-based workflows.

Turn a working agent demo into a production autonomous ai operations assistant with planning, tools, memory, approval gates, observability, and Streamlet-based workflow control.

Design complete agent architectures as bounded, boundary-defined components using a plan, operate, and evaluate model; implement a Python-based autonomous operations assistant with clear data flow and controls.

Combine planning, memory, tools, and agents into an autonomous AI operations assistant by turning the production design into a concrete Python component, and define visible decisions, evidence, and boundaries.

Implement human approval checkpoints in autonomous AI actions by using a propose–review–execute workflow, creating explicit, auditable approvals and risk-aware interfaces to control high-impact operations.

Explore agent observability by tracing events, metrics, and outcomes to understand workflow behavior without revealing reasoning. Build a Python component for an ai operations assistant and design safe event schemas.

Explore token and latency management for autonomous apps, implementing budgets for tokens and time, measurement, and optimization to build robust, production-ready AI workflows in Python.

Design and implement a SQLite-backed cache for model responses in Python, focusing on cache keys, freshness, invalidation, and observable hits to ensure safe, reusable results.

Develop layered safety guardrails that protect inputs, reasoning, tools, data, and outputs by implementing a defense-in-depth pipeline that prevents, detects, and responds to risks.

Define repeatable evaluation measures for correctness, usefulness, safety, and operational behavior, then implement a Python component for the autonomous AI operations assistant with a structured task rubric and JSON-based evidence.

Test agent workflows with unit, integration, and scenario tests, using deterministic mocks and regression checks, and build a Python component for the Autonomous AI Operations Assistant.

Deploy a user-friendly Streamlit interface for autonomous AI workflows by building a clear request form, progress indicators, approvals, and downloadable reports, while preserving persistent state and hiding secrets.

Extract stable patterns into modular contracts, adapters, and composition to design reusable agent components that enable scalable, testable autonomous apps with configurable infrastructure.

Develop an autonomous operations assistant with Python in hands-on lab 7, exploring AI agents and autonomous apps for practical, certified AI workflows.