Why an Agentic Workshop Is a Different Engagement

A generic AI workshop has to spend time on prompting, retrieval, and the basics of LLM application design. An agentic workshop assumes that baseline and goes straight into the work that breaks at scale. The team is past the demo and into the part of the project where context engineering, evaluation, and recovery are the actual job.

• Prerequisite: the team has shipped at least one LLM feature. Without that baseline, the agent labs assume too much
• Focus: orchestration, tools, memory, evaluation, observability, durability. Not prompting basics
• Output: a working multi-step agent built against the team's real data, in their actual stack
• Frameworks taught: LangGraph and OpenAI Agents SDK as primary, AutoGen and CrewAI referenced, Anthropic's "Building Effective Agents" as the reference text
• Format: usually two or three days, occasionally five for platform teams building shared agent infrastructure
• Anti-pattern caught early: the impulse to use multi-agent when a single agent with good tool design would solve the problem better

Curriculum: What the Workshop Covers

The curriculum below is the working module set for a two or three day agentic workshop in 2026. The selection is sequenced so that each module produces a working artifact the next module extends.

• Agent vs workflow: Anthropic's distinction, when to use which, the cost shape of agents in production
• Single-agent vs multi-agent: Cognition Labs' argument for single-agent dominance, Anthropic's case for multi-agent research subagents, the rule of thumb for picking
• Orchestration topologies: sequential, routing, supervisor, swarm, parallel orchestrator-workers, evaluator-optimizer loop
• Tool design: schema design, name and description craft, error message design, idempotency, dangerous-tool gates
• Model Context Protocol: writing MCP servers, exposing internal APIs as tools, the security model around tool surfaces
• Memory architecture: short-term scratchpads, long-term episodic and semantic stores, compaction strategies
• Memory frameworks: LangMem, Mem0, Zep, Letta, with code in the lab so the team has a working pattern
• Planning patterns: ReAct, Plan-and-Execute, Reflexion, Tree-of-Thoughts, and the hybrids that dominate production
• Evaluation for agents: trajectory-level eval, LLM-as-judge with rubrics, golden trajectories, the platforms that support it (LangSmith, Langfuse, Braintrust, Arize Phoenix)
• Observability: trace structure, span design, prompt versioning, the workflow for debugging a failed agent run
• Recovery and durability: idempotent tool design, retries, budget caps, human-in-the-loop checkpoints, durable execution with Temporal or Restate
• Cost and latency: prompt caching, streaming, smaller-model routing, the architecture choices that turn agents from cents to fractions of a cent per run
• Safety and guardrails: prompt injection defense, input sanitization, output validation, the policies that matter for regulated domains

Hands-On Outcomes

Every module produces an artifact. The artifacts compose into a working agent the team owns, deployable into their environment with minor cleanup. The reference implementation is the most valuable deliverable: not slides, not recordings, but code the team can extend.

• A working multi-step agent built during the session, against the team's real data
• Tool integration patterns lifted into the team's codebase
• MCP server exposing at least one internal API the team uses elsewhere
• Evaluation harness configured against trajectories the team cares about, ready to extend
• Observability hooks producing traces the team can read and debug
• Recovery patterns wired in: retries, idempotency, budget caps, checkpointing
• CI quality gate for the agent, integrated into the team's actual CI
• Architecture decision record: every choice documented with rationale, so the work survives turnover

Format Options

The agentic workshop is normally two or three days. Below that, the labs cannot reach durability; above that, the team's shipping work competes for attention.

• Two-day deep dive: foundations of agent design, single-agent build with tools and memory, evaluation, observability. The most common shape
• Three-day intensive: adds multi-agent patterns, MCP integration, durability with Temporal or Restate, full CI integration
• Five-day platform engagement: only justified for platform teams building shared agent infrastructure across the organization
• One-day variant: assumes a strong baseline, focuses on one capability gap (e.g. evaluation, MCP server design, durability)
• On-site: high-bandwidth, the right call when the team is co-located and budget supports travel
• Remote: works well for distributed teams already on Zoom or Slack discipline, lower cost
• Hybrid: rare for an agentic workshop, the labs benefit from synchronous facilitator attention

Audience and Prerequisites

The room should be a single engineering team that has already shipped an LLM feature. Without that baseline, the agent labs assume too much, and the team spends the workshop catching up on foundations.

• Engineers comfortable with Python or TypeScript who have shipped at least one production LLM feature
• Tech leads and architects who own the AI roadmap
• Staff and principal engineers welcome and material to the architecture conversations
• Engineering managers welcome for foundations and architecture, optional for deeper labs
• Optional: a product manager who owns the agent feature, attends the architecture and evaluation sessions
• Cohort size: 6-12 engineers is the sweet spot, 4-5 works but limits discussion, above 15 the facilitator cannot pair-work
• Pre-reading: Anthropic's "Building Effective Agents," OpenAI Agents SDK docs, Cognition Labs' "Don't Build Multi-Agents," Anthropic's research-agent post
• Setup before day one: dev environment running, repo cloned, API keys for at least two providers, sample data accessible, observability stack ready

Frameworks Taught and Compared

The workshop teaches patterns first, frameworks second. The team needs to understand orchestration topology and tool design independently of any single library, so they can pick the right tool when the labs end. The frameworks below are the working set in 2026.

• LangGraph: explicit graph-based control flow, typed state, first-class checkpointing. The default recommendation for production agents with non-trivial control flow
• OpenAI Agents SDK: lightweight handoffs, agent-as-tool composition, good fit for OpenAI-first stacks
• Microsoft AutoGen: conversational multi-agent, useful when the natural shape of the task is a multi-party conversation
• CrewAI: high-level role-and-task abstraction, fast to prototype, less expressive at the edges
• Model Context Protocol (MCP): the open standard from Anthropic for exposing tools, resources, and prompts. Build it once as an MCP server and every agent platform consumes it
• Temporal and Restate: durable execution engines for long-running agent workflows, the foundation for production reliability
• LangSmith, Langfuse, Braintrust, Arize Phoenix: observability and evaluation platforms, the workshop covers each at the level needed to pick
• LangMem, Mem0, Zep, Letta: memory frameworks, taught comparatively so the team picks the right write/retrieve policy

Pricing for an Agentic AI Workshop

Pricing for an agentic workshop runs higher than a generic AI workshop because the customization depth is higher. The labs are written against the team's actual stack, the reference implementation is engineered against their real data, and the facilitator is a senior practitioner who has shipped agents in production.

• Two-day deep dive: $25,000-$40,000, includes follow-up session and 30 days async Q&A
• Three-day intensive: $35,000-$55,000, the most common shape for engineering teams of 6-15
• Five-day platform engagement: $60,000-$150,000, for platform teams building shared agent infrastructure
• One-day focused variant: $12,000-$22,000, for teams with a strong baseline and one capability gap
• Add-ons: on-site travel pass-through, region-specific delivery, longer post-workshop retainer, dedicated code review hours
• What drives the upper end: customization depth, code review scope, post-workshop retainer commitment, on-site travel, multi-region delivery
• What drives the lower end: pure remote, single-team scope, fixed-pattern delivery (avoid), no post-workshop check-in
• Red flags: per-seat pricing on an agentic engagement, fixed syllabi labeled as "custom," providers who quote without a discovery call

Common Pitfalls This Workshop Catches Early

Most teams arrive at an agentic workshop carrying a few common misconceptions, often picked up from agent demos and tutorials. The workshop is designed to expose these in the first day so the rest of the engagement builds on solid ground.

• Multi-agent everywhere: the impulse to split work across agents when a single agent with good tool design would work better and cost less
• Tool surface bloat: 30+ tools on one agent, tool selection accuracy degrading measurably, performance gone before evaluation ever ran
• No idempotency: writes happening twice when the agent retries, side effects unrecoverable, the team afraid to enable retries in production
• Unbounded loops: agents running until the API key runs out, no step caps, no token caps, no wall time caps, no dollar caps
• No trajectory eval: the team scoring final outputs only, missing the tool-choice mistakes that compound into failures
• Memory without policy: persisting everything, retrieving by similarity only, model context bloating with stale facts
• No human-in-the-loop on irreversible actions: agents sending emails, charging cards, deleting records, with no approval gate
• Observability deferred: the team trying to debug a failed run from final outputs alone, the trace nowhere to be found

What the Team Walks Away Doing Differently

The honest measure of an agentic workshop is what the team is doing four weeks later that they were not doing before. The bar is uncomfortably high and forces the workshop to ship working code, not just teach patterns.

• Designs new agent features by picking the simplest pattern that works, not the most agentic one
• Writes tool schemas with tight types, verb-like names, and example-rich descriptions, and ships idempotency keys on every write tool
• Operates a trajectory-level eval harness and pins golden trajectories as regression tests
• Reads traces fluently and can debug a failed agent run from observability data in minutes, not hours
• Enforces step caps, token caps, dollar caps, and wall-time caps in the runtime, not in the model
• Picks frameworks based on the team's control-flow needs, not on what their first tutorial used
• Exposes internal APIs as MCP servers so every agent platform the company runs can use the same tools
• Defends the architecture in code review and in front of the next engineer who joins the team

FAQ