Building Agentic AI Workloads – Crash Course

This freeCodeCamp course covers building AI agents - systems that can take actions, use tools, and maintain memory. The course uses AWS Bedrock but concepts apply broadly.

The Evolution of AI

Historical Context:

• 1956: Dartmouth Workshop - AI term coined
• 1997: IBM Deep Blue beats Gary Kasparov
• 2011: IBM Watson wins Jeopardy
• 2022: ChatGPT released
• 2025: Year of AI Agents

Software Evolution:

• Software 1.0: Traditional programming
• Software 2.0: Machine learning models
• Software 3.0: AI agents that can reason and act

What Are AI Agents?

An AI agent is more than a chatbot - it can:

• Take multiple actions autonomously
• Use external tools
• Maintain short and long-term memory
• Make decisions based on context

Andrew Ng’s Definition: Agentic systems are AI that can plan, reason, and take actions to achieve goals.

Agent Architecture

Core Components

1. LLM (Brain): The reasoning engine
2. Tools: External capabilities the agent can use
3. Memory: Short-term (conversation) and long-term (persistent)
4. Orchestration: The loop that coordinates everything

The Agent Loop

User Input → LLM Reasoning → Tool Selection → Tool Execution →
Response Generation → (Loop continues if needed)

Tools

Tools extend what an agent can do:

• Get current time/weather
• Execute code
• Query databases
• Call external APIs
• Send emails

Tool Definition:

• Name and description
• Input parameters
• Execution logic

AWS Bedrock Converse API:

• Standardizes tool calling across models
• Handles tool use responses
• Manages conversation flow

Memory Systems

Short-term Memory

• Current conversation context
• Recent interactions
• Limited by context window

Long-term Memory

• Persistent storage
• User preferences
• Historical interactions
• Requires external database

Multi-Agent Systems

Instead of one agent doing everything:

• Supervisor Agent: Coordinates other agents
• Specialist Agents: Handle specific tasks
• Communication: Agents pass information between each other

Example Architecture:

User → Supervisor → [Math Agent, Weather Agent, Email Agent] → Response

Practical Considerations

Choosing a Framework

When to use frameworks (LangChain, etc.):

• Rapid prototyping
• Complex orchestration needs
• Built-in integrations

When to build custom:

• Simple use cases
• Need full control
• Performance critical

Evaluation

How to evaluate agents:

• Task completion rate
• Response accuracy
• Tool usage efficiency
• Cost per interaction

Compliance & Privacy

• Data handling policies
• User consent
• Audit trails
• Access controls

Best Practices

1. Use AI as a junior developer - Always review outputs
2. Focus on the human element - AI augments, doesn’t replace
3. Start simple - Add complexity only when needed
4. Monitor everything - Track costs, latency, accuracy
5. Handle failures gracefully - Fallback strategies

The Future

• More sophisticated reasoning
• Better tool integration (MCP standard)
• Multi-modal agents (text, image, audio)
• Autonomous task completion

Resources

• AWS Bedrock documentation
• LangChain, Anthropic, DeepLearning.AI academies
• Linux Foundation AI initiatives