SkillAI · The Beam

Autonomous AI Agent Engineering

0/82 concepts·~34 h left

1
Phase 010/7 · ~3 h left

1. LLM Fundamentals and Prompt Engineering

How Transformer architecture works and why it matters for agent design (attention, context windows, hallucination patterns)25 min
Tokenization deep dive: why gpt-4o charges per token and how to optimize costs25 min
Embeddings and semantic search: the backbone of agent memory (OpenAI text-embedding-3-small, Cohere embed-v3)25 min
Prompt engineering patterns that actually work in production: few-shot, zero-shot, role prompting, delimiters, XML tags25 min
System prompt architecture: how to write instructions that survive context overflow25 min
Evaluating LLM outputs with Promptfoo and DeepEval25 min
Understanding frontier models: GPT-4o, Claude 3.7 Sonnet, Gemini 2.0 Flash, Llama 3.3 70B — when to use each25 min
2
Phase 020/7 · ~3 h left

2. Agentic Patterns: ReAct, Chain of Thought, Tool Use

ReAct (Reason + Act): the loop that powers most production agents — how the LLM thinks, decides, acts, observes, and repeats25 min
Chain of Thought (CoT): making the model show its work — zero-shot CoT ("think step by step"), self-consistency, tree-of-thought25 min
Tool Use / Function Calling: OpenAI's tools API, Anthropic's tool_use, how to define schemas that models actually understand25 min
ReWOO: separating planning from execution to reduce token costs 40-60%25 min
Reflexion: agents that learn from their mistakes via self-reflection loops25 min
Combining patterns: when to use ReAct vs. pure function-calling vs. hybrid approaches25 min
Real-world case studies: how Devin, Cursor, and Claude Code use these patterns internally25 min
3
Phase 030/8 · ~3.5 h left

3. Building AI Agents with LangChain

LangChain architecture: chains, runnables, LCEL (LangChain Expression Language)25 min
Building agents with create_react_agent and AgentExecutor25 min
Tool ecosystem: DuckDuckGoSearchRun, PythonREPLTool, WikipediaQueryRun, custom tools25 min
Integrating with 50+ LLM providers via langchain-openai, langchain-anthropic, langchain-google-genai25 min
Memory in LangChain: ConversationBufferMemory, ConversationSummaryMemory, VectorStoreRetrieverMemory25 min
Structured output with PydanticOutputParser and .with_structured_output()25 min
Debugging with LangSmith: traces, latency, cost tracking per run25 min
Callbacks and streaming for real-time UX25 min
4
Phase 040/9 · ~4 h left

4. Building Stateful Agents with LangGraph

LangGraph mental model: nodes, edges, state, conditional routing25 min
Why graphs beat linear chains for complex agents (cycles, parallel branches, error recovery)25 min
StateGraph vs MessageGraph — when to use each25 min
Building a full agent loop with tool nodes, decision nodes, and human approval steps25 min
Human-in-the-loop: interrupt, review, resume patterns for high-stakes actions25 min
Parallel execution: running multiple agent branches simultaneously with Send()25 min
Persistence with SqliteSaver and PostgresSaver — agents that remember between sessions25 min
LangGraph Cloud: managed deployment with built-in streaming and persistence25 min
Subgraphs: composing complex multi-step workflows from smaller reusable graphs25 min
5
Phase 050/8 · ~3.5 h left

5. MCP (Model Context Protocol) Integration

MCP architecture: hosts, clients, servers, and the JSON-RPC 2.0 protocol underneath25 min
MCP primitives: Tools (actions), Resources (data), Prompts (templates)25 min
Building your first MCP server in Python with mcp SDK25 min
Connecting to existing MCP servers: filesystem, GitHub, PostgreSQL, Slack, Google Drive25 min
MCP in Claude Desktop, Cursor, Windsurf, and VS Code Copilot25 min
Context management strategies: what to expose, what to cache, how to avoid context overflow25 min
Security considerations: input sanitization, permission scoping, audit logging25 min
The MCP ecosystem in 2026: 500+ community servers, smithery.ai directory25 min
6
Phase 060/8 · ~3.5 h left

6. Multi-Agent Orchestration

Multi-agent architectures: hierarchical (supervisor + workers), peer-to-peer, blackboard systems25 min
CrewAI: role-based agents with defined goals, tools, and backstories — the easiest way to get a multi-agent team running25 min
AutoGen (Microsoft): conversation-based multi-agent framework with code execution25 min
OpenAI Swarm / OpenAI Agents SDK: lightweight orchestration with handoffs25 min
Agent communication protocols: shared state vs. message passing vs. tool calls25 min
Task decomposition: how a supervisor agent breaks complex tasks into subtasks and delegates25 min
Conflict resolution: what happens when agents disagree25 min
Debugging multi-agent systems with LangSmith traces and CrewAI's built-in logging25 min
7
Phase 070/8 · ~3.5 h left

7. Memory Systems: Short-Term and Long-Term

The 4 types of agent memory: in-context (conversation history), external semantic (vector DB), external episodic (event logs), procedural (learned behaviors)25 min
In-context memory optimization: sliding window, summarization, token budgeting25 min
Vector databases for semantic memory: Pinecone, Qdrant, Chroma, pgvector — tradeoffs and when to use each25 min
Mem0: the managed memory layer for AI agents — add/search/update memories with one API call25 min
Zep: long-term memory with automatic summarization and entity extraction25 min
Redis for short-term session memory: blazing fast, simple, ephemeral25 min
Memory retrieval strategies: MMR (Maximal Marginal Relevance), HyDE, time-weighted retrieval25 min
Entity memory: extracting and storing facts about users, projects, and relationships25 min
8
Phase 080/9 · ~4 h left

8. Agent Evaluation and Testing

Why traditional software testing fails for agents (non-determinism, emergent behavior)25 min
Evaluation dimensions: task success rate, faithfulness, answer relevancy, tool selection accuracy, hallucination rate25 min
RAGAS: automated RAG and agent evaluation framework — run 10K evaluations overnight25 min
AgentBench and GAIA benchmark: industry-standard agent benchmarks25 min
LLM-as-a-judge: using GPT-4o to evaluate GPT-4o outputs (and why it works)25 min
Red teaming agents: adversarial inputs, prompt injection attacks, jailbreak attempts25 min
Regression testing: building a test suite that catches regressions when you update prompts25 min
A/B testing agent versions in production with feature flags25 min
Cost/quality tradeoff analysis: when to use GPT-4o vs GPT-4o-mini vs Claude Haiku25 min
9
Phase 090/10 · ~4 h left

9. Production Deployment and Monitoring

Deployment patterns: REST API (FastAPI), WebSocket streaming, async queues (Celery + Redis)25 min
Containerizing agents with Docker — handling model credentials, secrets, environment vars25 min
Serverless deployment with Modal (best for AI workloads) and Railway25 min
LangServe: deploying LangChain agents as production-ready REST APIs in minutes25 min
Observability stack: LangSmith for traces + Prometheus + Grafana for metrics25 min
Cost monitoring: tracking $/1000 calls per agent, setting spend alerts25 min
Rate limiting, retries, and exponential backoff for LLM API calls25 min
Handling failures gracefully: fallback models, circuit breakers, user-facing error messages25 min
Scaling strategies: stateless agents + Redis for shared state, horizontal scaling with K8s25 min
Guardrails: NeMo Guardrails, Guardrails AI — input/output validation, content moderation25 min
10
Phase 100/8 · ~3.5 h left

10. Real-World Agentic Applications

Coding agents: how Cursor, Devin, and GitHub Copilot Workspace are built — file editing, test running, git operations25 min
Data analysis agents: natural language → SQL → charts (Text2SQL with validation loops)25 min
Browser automation agents: Playwright + LLM for autonomous web interaction (browser-use library)25 min
Document processing pipelines: PDF → structured data with LlamaParse + agent validation25 min
Customer support agents: intent classification, RAG-based FAQ, escalation logic, CRM integration25 min
Ethical deployment: bias auditing, transparency requirements, EU AI Act compliance for high-risk agents25 min
Building a Minimum Viable Agent (MVA): scope definition, risk assessment, rollout strategy25 min
Future landscape: OpenAI o3, Gemini 2.0 native tool use, agents with persistent browser sessions25 min