Week 1 – Agentic AI Foundations
Batch 09 – BeSA Cloud Academy
Disclaimer:
These notes were drafted using AI for clarity, structure, and readability. They are intended solely for learning purposes.
(1) Why Agentic AI? (GenAI vs Agentic AI)
The core idea discussed was the difference between traditional Generative AI and Agentic AI.
Generative AI (LLMs) act as the brain:
- Understand context
- Generate responses
- Provide suggestions or answers
However, they stop at reasoning. The execution is still done by the user. For example, an LLM can suggest travel options, but I still need to:
- Book flights
- Check hotel availability
- Compare prices
- Open multiple tabs and execute actions manually
This is where the limitation becomes clear.
Why simple scripts are not enough:
- Scripts assume fixed flows.
- Real-world situations are dynamic.
- If a condition changes (flight delay, inventory change, pricing update), scripts often fail.
- Complex workflows require adaptation and replanning.
Agentic AI introduces:
- Reasoning
- Planning
- Replanning
- Autonomous execution
Instead of only answering, the system can take actions and adjust in real time.
(2) What is an Agent?
Definition:
An agent is an entity that drives autonomous work on behalf of a user or business.
Important characteristics:
- Has a goal
- Can act independently
- Uses tools
- Can change its plan if needed
Analogy used: James Bond (007)
- Gets a mission (trigger)
- Assesses context
- Uses tools (gadgets)
- Adjusts plan when things change
- Completes the mission autonomously
Evolution of the technology:
Generative Assistant
- Basic automation
- Examples: spelling suggestions, summarization
AI Agent
- Executes a dynamic workflow
- Focused on achieving a single goal
Agentic AI System
- Multiple agents collaborating
- Multi-task and multi-system execution
- Comparable to coordinated teams (e.g., Avengers concept)
The progression is from static response → goal-driven execution → coordinated multi-agent systems.
(3) Anatomy of an Agent
Agents operate in a loop:
Think → Act → Evaluate/Reflect
This loop is important for understanding architecture.
The Brain (LLM)
- Responsible for reasoning
- Chooses which tool to use
- Makes decisions based on context
Planning / Orchestration
- Creates a path to the goal
- Adjusts path when something changes
- Enables replanning
Tools (Action Groups)
- APIs
- Lambda functions
- Databases
- External integrations
These are how the agent interacts with the outside world.
Memory
- Maintains context across interactions
- Prevents users from repeating information
- Enables continuity in conversations
Judge LLM (in complex systems)
- Acts as a reviewer
- Provides checks and balances
- Useful in multi-agent or high-risk workflows (e.g., supply chain scenarios)
The major takeaway:
An agent is not just an LLM. It is LLM + planning + tools + memory + control loop.
(4) Technical Implementation and Architecture (AWS Focus)
Amazon Bedrock
- Managed service for building and deploying agents
- Provides access to foundation models
- Supports agent configuration
Agent Core
- Handles runtime
- Memory management
- Observability capabilities
Instructions
Agents are guided using natural language instructions:
- Define role (e.g., “You are a car parts assistant”)
- Define guidelines
- Specify what tools are available
- Constrain behavior
This becomes the control layer for agent behavior.
Key architectural pillars discussed:
Security
- Agents should be treated like human identities.
- Assign restricted permissions.
- Apply least privilege principles.
- Each agent should have scoped access to resources.
Cost
- Token usage directly impacts cost.
- Complex reasoning and tool chaining increases token consumption.
- Need to monitor and optimize prompt and reasoning flows.
Observability
- Visibility into agent traces.
- Ability to inspect reasoning steps.
- Important for debugging and improving workflows.
Architectural thinking must include:
- Identity and access management
- Cost monitoring
- Traceability of decisions
(5) Important Conceptual Takeaways
- LLM alone is not an agent.
- Agents require structured orchestration.
- Real-world systems need replanning capability.
- Multi-agent systems introduce coordination complexity.
- Security and cost control are architectural responsibilities.
- Observability is essential for production systems.
Mental model to retain:
Agent = Brain (LLM) + Tools + Memory + Planning + Control Loop
End of Week 1 Notes
This session focused on conceptual foundations and architectural clarity. Future weeks will likely build deeper into implementation patterns and advanced agent systems.
I’ll continue documenting each week in this series for structured revision.
Top comments (0)