Prototyping AI and agent workflows in Python

AI transformation overview

Automation vs agentic systems

Identifying agent-worthy problems

ROI and feasibility analysis

Human-in-the-loop design and risk classification

Enterprise adoption patterns

Translating business problems into agent requirements

What are AI agents

Agentic AI vs traditional systems

Agent lifecycle and capabilities

Levels of autonomy in AI systems

Real-world examples of agent

Agent vs application mental models

Task decomposition

Reasoning strategies (CoT, ToT, ReAct)

Prompt structure design

Structured outputs with Pydantic

Reliability-first mindset

Role and persona prompting

Instruction hierarchies

afety boundaries

Deterministic outputs using schemas

Few-shot prompt libraries

Critic-creator loops

Self-refine and verification patterns

Unit-test-driven prompting

Automated critique rubrics

Failure-mode catalogues

Prompt chaining patterns

Guardrails and validators

Schema validation with Pydantic

Retries and error handling

Minimal orchestration in Python

Orchestrator-worker architecture

Evaluator-optimiser loops

Router patterns

Sequential vs parallel vs conditional workflows

Workflow design diagrams

Classifiers and intent routers

Routing strategies

Parallel fan-out/fan-in pipelines

Aggregation and conflict resolution

Idempotent workflows

Short-term state vs working memory

Message and state graphs

Ephemeral vs persistent memory

Context window management

Token budgeting

Specification-driven agents

Testing strategies

Invariants and safety checks

Exception-handling strategies

SLAs and SLOs for agent systems

Tool schemas

Secure tool adapters

Tool selection strategies

Loop prevention

API rate limits

Retries and timeouts

Pydantic models and structured outputs

Function-calling patterns

JSON/Avro data pipelines

Schema validation and versioning

REST and GraphQL integrations

Authentication flows and secrets management

Web search agents

Grounding and citation strategies

Text-to-SQL agents

Database interaction patterns

Constrained updates and transaction safety

Audit logging

Vector database fundamentals

Document indexing and chunking

Embeddings and vector search

Hybrid retrieval strategies

Query reformulation

Reranking

Hallucination control

Multi-corpus retrieval systems

Multi-tool retrieval orchestration

Caching strategies

Freshness and knowledge drift management

Semantic, episodic, and procedural memory

Embeddings hygiene

Session stitching

Privacy and lifecycle policies

Summarisation pipelines

Golden datasets and synthetic evaluation

RAGAS and evaluation frameworks

Step-wise vs outcome evaluation

Cost-quality trade-offs

Multi-agent architectures

Agent roles and capabilities

Shared tools

Communication patterns

Resource contention control

Global vs local state management

Locks and leases

Conflict detection

Consensus strategies

Concurrent agent coordination

Planner-executor models

Subgoal generation

Supervisor agents

Human-in-the-loop escalation

Failure-recovery strategies

Specialised retrievers

Synthesis agents

Cross-agent memory sharing

Multi-agent knowledge systems

Load testing and red-teaming

MCP servers and tools

Secure tool exposure

FastAPI services

Containerisation

Infrastructure choices (serverless vs Kubernetes)

System tracing

Metrics and logging

Prompt and version tracking

Token usage monitoring

Rate-limit strategies

Data governance and PII protection

Policy enforcement

Prompt injection defence

Tool misuse prevention

Red-team playbooks

Unit and integration testing for agents

Offline and online evaluation gates

CI/CD pipelines

Blue-green deployment

Rollback strategies

Production monitoring