Table of Contents

Welcome to my summary of Week 5, the final week at AI_devs. After exploring tool building and interfaces in Week 4, this week focused on creating advanced AI agents and bringing together everything we’ve learned throughout the course. This post will not only cover our final week but also include my reflections and takeaways from the entire AI_devs journey.

AI_devs summaries:

Introduction

Our final week focused on building advanced AI agents that can work autonomously while maintaining reliability and safety. We explored:

  • Core agent architecture and design principles
  • Advanced planning and reasoning systems
  • Multi-agent collaboration
  • Production deployment considerations
  • Real-world implementation challenges

Throughout this week, we brought together everything we learned about LLMs, data processing, tool building, and system design to create comprehensive AI agent systems.

Day 1: Building Practical AI Agents

Our first day focused on turning theory into practice. We practiced how to build AI agents that can work independently - not just respond to questions like chatbots.

Unlike the tools we built in previous weeks, these agents can independently decide how to approach tasks and when to complete them. This autonomy is achieved through a loop-based system where the model (with programmatic limits) decides when to exit.

The core mechanics include:

  • Planning: Agents analyze their current situation using available knowledge and tools to determine next steps
  • Memory: Agents maintain both conversation history and action records
  • Tools: Agents can access and utilize various tools as needed

We explored four key agency patterns that form the foundation of advanced AI systems:

  1. Reflection - analyzing current situations and context
  2. Tools - selecting and utilizing appropriate tools for tasks
  3. Planning - creating action lists based on goals and available information
  4. Agent Teams - enabling specialized agents to collaborate toward common goals

The key takeaway was that AI agents are essentially a series of controlled loops overseen by language models, with necessary programming constraints. Given current LLM limitations, the focus is on building specialized agents with specific skills and straightforward memory systems, while maintaining flexibility for future expansion.

Practical Task: Conversation Analysis Agent

Today’s challenge was to build an agent that could analyze conversations and check facts. The tricky part was that some conversations had wrong information that needed to be checked against reliable sources.

I already had an agent that could handle this kind of data processing, so I focused on improving its prompts to better verify facts.

Day 2: Advanced Agent Planning Systems

Day 2 showed us how to make AI agents better at planning their work. We learned how agents can think through tasks step by step, like a person planning a complex project.

The agent works through five main stages:

  1. Initial Assessment - Understanding the current situation
  2. Task Planning - Creating a list of needed tasks and updating it as things change
  3. Action Selection - Choosing what to do next
  4. Preparation - Getting ready to use the right tool
  5. Execution - Running the chosen tool and saving its results

This approach helps agents break big tasks into smaller ones and adjust their plans when needed. The key is that agents don’t just follow fixed rules - they can think about what they’re doing and change course if necessary.

Practical Task: GPS Location Tracker

Today’s challenge was to build an agent that could track people using GPS data. The agent needed to:

  • Get user IDs from a database
  • Fetch GPS coordinates for each person
  • Combine all location data
  • Remove certain data for privacy reasons

The interesting part was that the agent had to decide:

  • Which API to use at each step
  • What data it needed and when
  • How to process and filter the results

This task showed how agents can handle sensitive data and make decisions about when and how to use different APIs. I built a system that could think through each step and make smart choices about data collection and processing.

Are you interested in staying up-to-date with the latest developments in #Azure, #CloudComputing, #PlatformEngineering, #DevOps, #AI?

Follow me on LinkedIn for regular updates and insights on these topics. I bring a unique perspective and in-depth knowledge to the table. Don't miss out on the valuable content I share – give me a follow today!

Day 3: Building Flexible Agent Systems

Day 3 focused on creating flexible agent systems and choosing between different implementation approaches. We compared built-in tools like Function Calling with custom code solutions.

We learned three key principles for building reliable agent systems:

  1. Flexible Core Logic - Making agents that can easily add or remove tools
  2. Consistent Data Format - Using the same document structure for memory, skills, and processing
  3. Independent Tools - Building tools that can work both with agents and on their own

Practical Task: Multi-Source Query API

Today’s challenge was to build an API that could work with an external AI agent. The API needed to:

  • Answer questions using multiple sources (documents, images, websites)
  • Respond within 6 seconds
  • Implement caching for web content

I built a system that could quickly combine information from different sources while staying within the time limit. The key was smart caching, especially for web content that takes longer to fetch.

Day 4: Real-World Agent Implementation

Day 4 showed us how to move from theory to practice with AI agents. We explored three approaches:

  1. Real-Time Agents - Building systems that can respond quickly and handle live interactions
  2. Agents as Tools - Using agents as specialized components in larger systems
  3. Learning Agents - Creating agents that can gather and organize knowledge

The key takeaway was that while we can build agents that work independently, we’re not yet at the point of fully autonomous systems. Instead, we should focus on:

  • Building agents for specific tasks
  • Setting clear boundaries and limits
  • Starting with personal or internal company projects
  • Using existing tools and frameworks when possible

Practical Task: Smart API and LLM Hacking

Today’s challenge had two interesting parts:

  1. Building an API that could answer questions intelligently - similar to yesterday’s task but with different requirements
  2. “Hacking” a provided LLM model to extract a hidden flag - this was a fascinating exercise in prompt injection and understanding model vulnerabilities

Day 5: Building Complete AI Agents

The final day was special - we received the source code of Alice AGI, a full-featured AI agent built by one of our course instructors. This wasn’t just example code - it was a working system that showed how to combine everything we learned throughout the course.

Alice AGI demonstrated practical implementations of:

  • Memory systems
  • Tool integration
  • Multi-modal interactions
  • Planning and reasoning

Getting access to this production-ready code was invaluable. It showed real solutions to challenges we’d been discussing and provided a blueprint for building our own advanced agents.

Practical Task: Comprehensive Agent Challenge

Our final task was to build our most advanced agent yet. The agent needed to:

  • Process all materials from the Agent 5 storyline
  • Answer questions using this complete knowledge base
  • Demonstrate everything we learned about agent architecture

This was a perfect final challenge - it required using all the skills we developed throughout the course to create a truly capable AI agent system.

Course Summary and Final Thoughts

Mission Accomplished! After five intense weeks, my journey with AI_devs has come to an end. This wasn’t just another programming course - it was an adventure into the world of AI agents that brought together nearly 4,000 participants.

The Experience

The course had a unique storyline where each participant became Agent 5, tasked with uncovering the secrets of robot hearts. Every morning at 5 AM, we received:

  • A new lesson with practical knowledge
  • A piece of the ongoing story
  • A challenging task to complete

The course even included bonus “capture the flag” missions that added extra excitement to the learning process.

What I Learned

While the course examples were in TypeScript, I chose to implement my solutions in Go. Throughout the five weeks, we covered:

  • LLM fundamentals and advanced prompting
  • Multimodal models for processing text, audio, and images
  • Vector and graph databases
  • Semantic search and embedding-based content matching
  • Building practical AI agent systems

The learning resources were extensive:

  • 65 example projects explaining different concepts
  • Hands-on experience building nearly 20 practical applications
  • Mix of API development and AI agent implementations

Community Impact

One of the most valuable aspects was the incredible AI_devs community. The discussions, experience sharing, and mutual support made this journey even more worthwhile. Having almost 4,000 developers learning and building together created an amazing learning environment.

Looking Forward

The skills and knowledge gained from AI_devs have opened up new possibilities for both personal projects and enterprise applications. Understanding how to build AI agents that can work autonomously while maintaining safety and reliability is invaluable in today’s rapidly evolving tech landscape.

Thank you for following my AI_devs journey! I’m excited to apply these skills in future projects and continue exploring the fascinating world of AI development.

AI_Devs certificate
AI_Devs certificate

Do you like this post? Share it with your friends!

You can also subscribe to my RSS channel for future posts.