Agentic AI Software Engineering: Build & Deploy Production Agents

You can explain the difference between a prompt, a chain and an agent, and decide honestly whether a given problem needs an agent at all.

1. From completion to conversation to agency90 min
   • single-shot completion
   • chained prompts
   • the agent loop
   • autonomy spectrum
   • human-in-the-loop
2. When an agent is the wrong answer90 min
   • deterministic alternatives
   • cost per task
   • latency budget
   • failure tolerance
   • regulatory constraints
3. Anatomy of the agent loop90 min
   • observation
   • reasoning step
   • action selection
   • tool invocation
   • termination condition
4. Agent frameworks and the build-vs-adopt decision90 min
   • LangGraph
   • AutoGen
   • framework lock-in
   • raw SDK control
   • migration cost
5. Model selection for agent workloads90 min
   • Claude Opus 5
   • Claude Sonnet 5
   • Claude Haiku 4.5
   • reasoning vs speed
   • cost per million tokens
6. Setting up the development environment90 min
   • API key management
   • virtual environments
   • Cursor IDE setup
   • request logging
   • local secrets hygiene

Hands-on project: Write a decision memo for three real automation requests, recommending prompt, workflow or agent for each with the reasoning and the cheaper alternative stated.

You can write the async, typed, well-structured code an agent system needs, instead of scripts that work once and cannot be tested.

1. Async programming and concurrency control90 min
   • asyncio fundamentals
   • task groups
   • semaphore throttling
   • timeout handling
   • cancellation
2. Type systems: Pydantic and TypeScript interfaces90 min
   • Pydantic models
   • field validation
   • discriminated unions
   • Zod schemas
   • runtime vs compile-time
3. Error handling, retries and backoff90 min
   • exponential backoff
   • jitter
   • idempotency keys
   • circuit breaker
   • dead letter handling
4. Structured logging and correlation IDs90 min
   • structured log events
   • trace correlation
   • redaction of secrets
   • log levels
   • sampling
5. Testing non-deterministic systems90 min
   • response fixtures
   • snapshot testing
   • seed control
   • flake quarantine
   • contract tests
6. Project layout and dependency management90 min
   • package structure
   • uv and poetry
   • lockfiles
   • environment parity
   • reproducible builds

Hands-on project: Build a typed, fully async client library that wraps an LLM API with retries, timeouts and structured logging, covered by unit tests.

You can call a model API correctly under production conditions, streaming responses, counting tokens and keeping cost per request predictable.

1. The Messages API and conversation construction90 min
   • system prompt
   • user and assistant turns
   • multi-turn state
   • message ordering
   • role discipline
2. Streaming responses and partial output handling90 min
   • server-sent events
   • chunk assembly
   • partial JSON
   • early termination
   • client backpressure
3. Tokenisation, context windows and truncation90 min
   • token counting
   • context window limits
   • truncation strategy
   • summarisation fallback
   • overflow detection
4. Prompt caching and cost control90 min
   • cache breakpoints
   • cache hit economics
   • TTL behaviour
   • stable prefix design
   • cache invalidation
5. Rate limits, quotas and queueing90 min
   • requests per minute
   • tokens per minute
   • 429 handling
   • request queueing
   • priority lanes
6. Latency budgets and model routing90 min
   • p50 and p99 latency
   • model tiering
   • fast path routing
   • speculative execution
   • timeout policy

Hands-on project: Instrument an agent endpoint so every call records input tokens, output tokens, latency and cost, and surface it on a dashboard.

You can write a system prompt that holds up across hundreds of varied inputs, and build the context an agent sees deliberately rather than by accident.

1. System prompt architecture90 min
   • role definition
   • capability boundaries
   • output contract
   • refusal conditions
   • tone specification
2. Context assembly and ordering90 min
   • relevance ranking
   • recency weighting
   • position effects
   • context budget allocation
   • deduplication
3. Few-shot examples and when they hurt90 min
   • example selection
   • format anchoring
   • overfitting to examples
   • negative examples
   • example rotation
4. Chain-of-thought and extended thinking90 min
   • reasoning prompts
   • thinking budgets
   • hidden vs visible reasoning
   • verbosity control
   • cost implications
5. Prompt versioning and A/B testing90 min
   • prompt registry
   • version pinning
   • traffic splitting
   • metric selection
   • rollback procedure
6. Guardrails in the prompt layer90 min
   • scope restriction
   • output format enforcement
   • escalation triggers
   • uncertainty expression
   • refusal handling

Hands-on project: Rewrite a failing agent's system prompt and context assembly, then prove the improvement on a fifty-case regression set.

You can design a tool surface an agent uses correctly, with schemas that make wrong calls impossible rather than merely discouraged.

1. Tool definitions and JSON schema design90 min
   • schema structure
   • required vs optional
   • enum constraints
   • description writing
   • parameter naming
2. Tool selection behaviour and disambiguation90 min
   • overlapping tools
   • tool count effects
   • forced tool use
   • parallel tool calls
   • selection debugging
3. Argument validation and coercion90 min
   • schema validation
   • type coercion
   • range checks
   • injection-safe parsing
   • validation error feedback
4. Tool result formatting and error surfaces90 min
   • result shaping
   • truncating large results
   • error message design
   • partial success
   • retry signalling
5. Structured output and schema-constrained generation90 min
   • JSON mode
   • schema enforcement
   • parse failure recovery
   • nested structures
   • streaming structured output
6. Building an MCP server for reusable tools90 min
   • Model Context Protocol
   • server lifecycle
   • resource exposure
   • transport options
   • client configuration

Hands-on project: Build a six-tool agent for a support workflow, with JSON schemas, argument validation, and a test proving each tool is selected for the right intent.

You can build retrieval that actually improves answers, measured on a labelled set, rather than adding a vector database and hoping.

1. Chunking strategies and document structure90 min
   • fixed-size chunking
   • semantic chunking
   • heading-aware splits
   • overlap tuning
   • metadata attachment
2. Embeddings and vector stores90 min
   • embedding models
   • dimensionality
   • cosine similarity
   • index types
   • Pinecone and pgvector
3. Hybrid search: dense plus lexical90 min
   • BM25 scoring
   • reciprocal rank fusion
   • filter pushdown
   • metadata filtering
   • recall tuning
4. Reranking and result selection90 min
   • cross-encoder reranking
   • top-k selection
   • diversity enforcement
   • score thresholds
   • latency cost
5. Retrieval evaluation90 min
   • labelled query set
   • recall at k
   • precision at k
   • answer faithfulness
   • regression tracking
6. Agentic retrieval and query rewriting90 min
   • query decomposition
   • iterative retrieval
   • self-query
   • retrieval as a tool
   • stopping criteria

Hands-on project: Build a retrieval layer over a technical documentation corpus and demonstrate a measured improvement in answer accuracy against a no-retrieval baseline.

You can give an agent memory that stays useful over a long session without the context window or the bill growing without bound.

1. Conversation state and turn management90 min
   • turn history
   • state serialisation
   • session boundaries
   • resumption
   • concurrent sessions
2. Context compaction and summarisation90 min
   • rolling summary
   • salience selection
   • compaction triggers
   • information loss audit
   • summary drift
3. Long-term memory stores90 min
   • fact extraction
   • memory write policy
   • retrieval on demand
   • contradiction handling
   • memory decay
4. Episodic memory and task continuity90 min
   • episode boundaries
   • checkpointing
   • resume semantics
   • partial progress
   • idempotent replay
5. Scratchpads and working memory90 min
   • intermediate notes
   • plan storage
   • file-based scratchpad
   • cleanup policy
   • inspection
6. Privacy and retention in memory systems90 min
   • PII detection
   • retention windows
   • user deletion requests
   • encryption at rest
   • audit trail

Hands-on project: Implement a three-tier memory system for a long-running assistant and show token usage staying flat across a hundred-turn conversation.

You can make an agent break a vague goal into ordered, checkable steps and recover sensibly when a step fails.

1. Plan-and-execute versus react loops90 min
   • ReAct pattern
   • plan-then-act
   • replanning triggers
   • loop termination
   • step budgets
2. Task decomposition and dependency ordering90 min
   • subtask extraction
   • dependency graph
   • parallelisable steps
   • critical path
   • granularity choice
3. Self-critique and reflection90 min
   • reflection prompts
   • critique-revise loops
   • diminishing returns
   • cost of reflection
   • objective checks
4. Failure detection and recovery90 min
   • step validation
   • error classification
   • retry vs replan
   • escalation to human
   • partial rollback
5. Budget enforcement: steps, tokens and wall clock90 min
   • step counters
   • token budgets
   • deadline propagation
   • graceful degradation
   • budget exhaustion handling
6. Deterministic fallbacks90 min
   • rule-based fallback
   • cached answers
   • human handoff
   • failure messaging
   • SLA protection

Hands-on project: Build a planner that decomposes a multi-file refactoring request into ordered steps with explicit preconditions and a rollback path for each.

You can build a multi-agent graph with explicit state, conditional routing and checkpointing, and explain why each handoff exists.

1. Graph state, nodes and edges90 min
   • state schema
   • node functions
   • conditional edges
   • entry and exit points
   • graph compilation
2. Supervisor and router patterns90 min
   • supervisor node
   • routing logic
   • agent specialisation
   • handoff contracts
   • loop prevention
3. Checkpointing and durable execution90 min
   • checkpointer backends
   • thread identity
   • state snapshots
   • resume semantics
   • time travel debugging
4. Human-in-the-loop interrupts90 min
   • interrupt points
   • approval gates
   • state editing
   • resume after approval
   • timeout on approval
5. Parallel branches and fan-in90 min
   • parallel nodes
   • result aggregation
   • partial failure
   • ordering guarantees
   • race conditions
6. When multi-agent is overkill90 min
   • coordination overhead
   • token multiplication
   • debugging difficulty
   • single-agent baseline
   • measured comparison

Hands-on project: Build a four-node LangGraph system (router, researcher, writer, reviewer) with persistent checkpoints and a demonstrated resume after process restart.

You can let an agent run generated code without giving it a path to your infrastructure, and prove the containment holds.

1. Threat model for code-executing agents90 min
   • untrusted code
   • resource exhaustion
   • data exfiltration
   • lateral movement
   • supply chain risk
2. Container isolation and runtime hardening90 min
   • rootless containers
   • seccomp profiles
   • capability dropping
   • read-only root
   • tmpfs scratch
3. Network egress control90 min
   • network namespace
   • egress allowlist
   • DNS restriction
   • proxy interception
   • no-network default
4. Resource limits and timeouts90 min
   • CPU quota
   • memory cgroup
   • pid limits
   • wall-clock timeout
   • disk quota
5. Filesystem boundaries and artefact passing90 min
   • bind mount scope
   • input staging
   • output extraction
   • path traversal defence
   • artefact scanning
6. Escape testing and sandbox validation90 min
   • escape attempt suite
   • privilege probing
   • resource bomb tests
   • regression on upgrade
   • findings log

Hands-on project: Build a container sandbox that executes agent-generated Python with no network, a read-only filesystem and a hard CPU and memory cap, then attempt to escape it.

You can identify where untrusted text enters an agent and stop it from becoming an instruction, which is the dominant security failure in agent systems.

1. Prompt injection: direct and indirect90 min
   • direct injection
   • indirect via documents
   • tool output injection
   • multi-hop injection
   • payload taxonomy
2. The instruction and data boundary90 min
   • trusted instruction sources
   • untrusted content marking
   • delimiter strategies
   • provenance tracking
   • defence in depth
3. Least privilege for tools and credentials90 min
   • scoped tokens
   • per-tool credentials
   • short-lived secrets
   • no ambient authority
   • approval for writes
4. Data exfiltration paths90 min
   • URL construction
   • image loading
   • tool argument leakage
   • log leakage
   • egress monitoring
5. Output filtering and action confirmation90 min
   • destructive action gating
   • confirmation prompts
   • allowlist of targets
   • dry-run mode
   • audit before execute
6. Red-teaming your own agent90 min
   • payload library
   • automated adversarial tests
   • severity scoring
   • regression suite
   • disclosure process

Hands-on project: Run a red-team exercise against your own agent with twenty injection payloads, then implement and measure the mitigations.

You can prove an agent change is an improvement with numbers, instead of trying three prompts and keeping the one that felt best.

1. Designing an evaluation set90 min
   • case selection
   • difficulty distribution
   • edge case coverage
   • labelling process
   • set maintenance
2. Deterministic assertions and programmatic checks90 min
   • exact match
   • schema validation
   • tool call assertions
   • side-effect checks
   • regex constraints
3. LLM-as-judge and its failure modes90 min
   • judge prompts
   • position bias
   • verbosity bias
   • self-preference
   • judge calibration
4. Trajectory evaluation for multi-step agents90 min
   • step-level scoring
   • path efficiency
   • unnecessary tool calls
   • recovery quality
   • terminal state check
5. Regression testing in CI90 min
   • eval in pipeline
   • pass thresholds
   • cost ceiling per run
   • flake handling
   • result storage
6. Online evaluation and user feedback90 min
   • thumbs signal
   • implicit feedback
   • sampling for review
   • drift detection
   • feedback to eval set

Hands-on project: Build a hundred-case evaluation suite with automated scoring, wire it into CI, and block a pull request that regresses pass rate.

You can answer why a specific agent run behaved as it did, after the fact, from traces rather than from guesswork.

1. Tracing agent runs end to end90 min
   • span hierarchy
   • run identity
   • tool spans
   • token attribution
   • trace sampling
2. LangSmith and OpenTelemetry integration90 min
   • tracer setup
   • custom attributes
   • exporter configuration
   • PII redaction
   • retention policy
3. Cost attribution and budgets90 min
   • per-run cost
   • per-tenant attribution
   • budget alerts
   • cost anomaly detection
   • model mix analysis
4. Failure taxonomy and alerting90 min
   • tool failures
   • loop exhaustion
   • timeout rate
   • refusal rate
   • alert thresholds
5. Debugging a bad run from its trace90 min
   • replay from trace
   • prompt reconstruction
   • diff against good run
   • root cause patterns
   • fix verification
6. Dashboards and operational review90 min
   • golden signals
   • weekly review ritual
   • regression tracking
   • capacity planning
   • on-call runbook

Hands-on project: Instrument an agent with full tracing and build a dashboard showing per-run cost, step count, tool error rate and p95 latency.

You can run an agent as a real service, with versioning, rollout control and a tested way to turn it off.

1. Packaging agents as services90 min
   • API surface design
   • async job pattern
   • webhook callbacks
   • idempotent submission
   • request validation
2. Containerisation and deployment topology90 min
   • Dockerfile layering
   • health endpoints
   • graceful shutdown
   • horizontal scaling
   • resource requests
3. Versioning prompts, tools and models together90 min
   • version manifest
   • pinned model ids
   • compatibility matrix
   • rollback bundle
   • change log
4. Progressive rollout and kill switches90 min
   • canary percentage
   • automated rollback
   • feature flags
   • kill switch design
   • blast radius limits
5. Load testing and concurrency limits90 min
   • throughput ceiling
   • queue depth
   • backpressure
   • connection pooling
   • provider rate limits
6. On-call, incidents and post-mortems90 min
   • runbook authoring
   • severity levels
   • incident timeline
   • blameless post-mortem
   • action item tracking

Hands-on project: Deploy an agent behind an API with canary rollout, a feature flag kill switch, and a load test establishing its concurrency ceiling.

You can ship an agent that reads an issue, writes code, runs tests in a sandbox, opens a pull request and responds to review comments, with evaluation, tracing and a kill switch.

1. Architecture and scope definition90 min
   • capability boundary
   • non-goals
   • tool inventory
   • state design
   • success criteria
2. Repository comprehension and retrieval90 min
   • code indexing
   • symbol search
   • dependency graph
   • relevant file selection
   • context budgeting
3. Implementation loop with sandboxed execution90 min
   • patch generation
   • sandbox test run
   • failure feedback loop
   • iteration limits
   • diff validation
4. GitHub integration and review handling90 min
   • issue parsing
   • branch and commit
   • PR creation
   • review comment ingestion
   • follow-up commits
5. Evaluation, tracing and cost dashboard90 min
   • task success rate
   • eval harness
   • trace wiring
   • cost per PR
   • dashboard assembly
6. Security review and production readiness90 min
   • injection testing
   • credential scoping
   • kill switch test
   • runbook
   • go-live checklist

Hands-on project: Build and deploy an autonomous PR agent against a real repository: issue triage, repository comprehension, sandboxed implementation, test execution, PR creation, review-comment handling, with an eval suite, full tracing, cost dashboard and documented security model.