Therefore, I’m going all in on agentic AI systems. Here’s what I’m proposing to work on during the next 13 weeks.

Project Proposal

This project is about learning how to design, build and deploy multi-agentic AI systems.

1. Vision statement

   This project will add to my skills in AI system design and development following the different projects implemented during the CSPB program:

   • CSPB 1300: C++ Implementation of a Basic Recurrent Neural Network.

   • CSPB 4830: n8n AI automation workflow for construction costing.

   • CSPB 3308: AI Technical Interview Assistant.

   • Personal Project: AI Grader & Rich Feedback for continuous education programs.

2. Motivation

   My moonshot goal is to obtain a PhD in Computer Science and I’m studying different CS topics such as HCI, AI and Social Computing and their application in adult learning (Andragogy), upskilling, reskilling, self fulfillment and career change.

3. Specific and measurable goals (learning objectives) for the project Ability to understand, explain and implement the following:

   • Agent Design Concepts (Chain of Thought - CoT and Reasoning/Acting Framework - ReAct)

   • Multi Agent Design Patterns (Router, Parallel, Serial, Orchestrator)

   • Adding Guardrails to Agent output (Programmatic and LLM Judging)

   • Use of Short and Long Term Memory

   • Retrieval Augmented Generation (RAG) and vector databases (Pinecone, PgVector, etc…)

   • Integration with Tools (Model Context Protocol)

4. Risks to project completion, possibly including:

   1. Busy with life and work commitments.

5. Mitigation strategy for the risks listed above

   1. Take a structured approach to learning by following the Udacity Agentic AI Curriculum.

   2. Implement the 4 projects in the Udacity Agentic AI course and have them graded.

   3. Review the Github Actions course on MS certification page and Linkedin Learning.

   4. Blog about my learnings on a weekly basis.

   5. Choose a capstone project with publicly available data.

   6. Follow this loosely designed schedule:

   • [x] Week 01: Prepare project proposal & research topics

   • [x] Week 02: Udacity: Course 1 - Prompting For Effective Reasoning & Planning - Submit P1

   • [x] Week 03: Udacity: Course 2 - Agentic Workflows - Submit P2

   • [x] Week 04: Udacity: Course 3 - Building Agents

   • [x] Week 05: Udacity: Course 3 - Building Agents

   • [x] Week 06: Udacity: Course 3 - Submit P3

   • [x] Week 07: Udacity Course 4 - Multi-Agent Systems

   • [x] Week 08: Udacity Course 4 - Multi-Agent Systems

   • [x] Week 09: Udacity Course 4 - Submit P4 & Obtain Certificate

   • [x] Week 10: Github Actions - Review MS official course

   • [x] Week 11: Github Actions - Review Linkedin Learning Course - Take Exam

   • [ ] Week 12: Capstone Project: Graduate Record Exam (GRE) AI Essay Tutor

   • [ ] Week 13: Capstone Project: Graduate Record Exam (GRE) AI Essay Tutor

6. Project assessments - provide a list of evaluation criteria for the project

   1. Obtained the Udacity Agentic AI Nanodegree. [x]

   2. Deployed an Agent using a CI/CD pipeline. [x]

   3. Bonus: Take the Github Actions Certifications Exam [x]

7. Project portfolio link: https://starterpad.com

Week 09 [Mar 23 - Mar 30, 2026]

What did you do last week?

Last week, I worked on two main tasks that include:

1. Deploy the Udacity project #4 multi-agent system onto AWS.

2. Participate in the Replit4 Buildation using their latest Agent 4 tool.

Deployment was a great exercise and I used Github Copilot to assist with the deployment process after thinking about and setting up the following deployment plan:

• Open up an endpoint for my agentic system to receive customer requests. That can be done by using FastAPI.

• Dockerize the application and push the image to ECR (Amazon Elastic Container Registry)

• Create a running container from the stored image in ECS (Amazon Elastic Container Service)

• Build a Github Actions workflow to allow automated CI/CD

FAST API

The multi-agent system provides the ability to quote for paper supplies and to automatically process orders through the orchestrator agent.

Two main endpoints were created at /quote and /process-order to either get a quote or process a new order in addition to /health and /ready to check if the multi-agent system is ready.

This is an example request:

and relevant response to get a quote":

{
    "status": "success",
    "parsed_items": [
        {
            "requested_name": "A4 glossy paper",
            "canonical_name": "Glossy paper",
            "quantity": 200
        },
        {
            "requested_name": "cardstock",
            "canonical_name": "Cardstock",
            "quantity": 100
        },
        {
            "requested_name": "envelopes",
            "canonical_name": "Envelopes",
            "quantity": 50
        }
    ],
    "inventory_assessment": {
        "supported_items": [
            {
                "requested_name": "A4 glossy paper",
                "canonical_name": "Glossy paper",
                "quantity": 200,
                "unit_label": "units"
            },
            {
                "requested_name": "cardstock",
                "canonical_name": "Cardstock",
                "quantity": 100,
                "unit_label": "units"
            },
            {
                "requested_name": "envelopes",
                "canonical_name": "Envelopes",
                "quantity": 50,
                "unit_label": "units"
            }
        ],
        "unsupported_items": [],
        "in_stock_items": [
            {
                "item_name": "Cardstock",
                "quantity": 100,
                "stock_available": 395,
                "unit_price": 0.15
            }
        ],
        "reorder_items": [
            {
                "item_name": "Glossy paper",
                "requested_qty": 200,
                "stock_available": 187,
                "shortage": 13,
                "eta": "2025-04-02",
                "unit_price": 0.2,
                "reorder_cost": 2.6
            },
            {
                "item_name": "Envelopes",
                "requested_qty": 50,
                "stock_available": 0,
                "shortage": 50,
                "eta": "2025-04-02",
                "unit_price": 0.05,
                "reorder_cost": 2.5
            }
        ],
        "blocked_items": [],
        "can_fulfill": true,
        "reason": []
    },
    "quote": {
        "line_items": [
            {
                "requested_name": "A4 glossy paper",
                "item_name": "Glossy paper",
                "quantity": 200,
                "unit_price": 0.2,
                "line_total": 40.0
            },
            {
                "requested_name": "cardstock",
                "item_name": "Cardstock",
                "quantity": 100,
                "unit_price": 0.15,
                "line_total": 15.0
            },
            {
                "requested_name": "envelopes",
                "item_name": "Envelopes",
                "quantity": 50,
                "unit_price": 0.05,
                "line_total": 2.5
            }
        ],
        "subtotal": 57.5,
        "discount": 0.0,
        "total": 57.5,
        "historical_matches": [
            {
                "original_request": "I need to order 10 reams of standard copy paper, 5 reams of cardstock, and 3 boxes of assorted colored paper. I need the order delivered by April 10, 2025, for an upcoming meeting.",
                "total_amount": 60,
                "quote_explanation": "For your order of 10 reams of standard copy paper, 5 reams of cardstock, and 3 boxes of assorted colored paper, I have applied a friendly bulk discount to help you save on this essential supply for your upcoming meeting. The standard pricing totals to $64.00, but with the bulk order discount, I've rounded the total cost to a more budget-friendly $60.00. This way, you receive quality materials without feeling nickel and dimed.",
                "job_type": "school board resouorce manager",
                "order_size": "large",
                "event_type": "meeting",
                "order_date": "2025-01-01T00:00:00"
            },
            {
                "original_request": "I would like to place an order for 500 sheets of high-quality cardstock in various colors, 200 sheets of standard printer paper, and 1000 flyers printed in full color. I need these supplies delivered by April 15, 2025, to ensure everything is ready for the festival. Thank you.",
                "total_amount": 780,
                "quote_explanation": "Thank you for your order! For the 500 sheets of high-quality cardstock in various colors, we will provide a bulk discount, reducing the cost to $0.12 per sheet. The 200 sheets of standard printer paper will remain at $0.05 per sheet. For the 1000 full-color flyers, we'll keep the cost at $0.15 each. With these adjustments, we've rounded the total to ensure you get a great deal while keeping your festival budget in check.",
                "job_type": "event manager",
                "order_size": "small",
                "event_type": "festival",
                "order_date": "2025-01-01T00:00:00"
            },
            {
                "original_request": "I would like to request a large order of high-quality paper supplies for an upcoming event. We need 500 reams of A4 paper, 300 reams of letter-sized paper, and 200 reams of cardstock. Please ensure the delivery is made by April 15, 2025. Thank you.",
                "total_amount": 96,
                "quote_explanation": "Thank you for your large order! We have calculated the costs for 500 reams of A4 paper at $0.05 each, 300 reams of letter-sized paper at $0.06 each, and 200 reams of cardstock at $0.15 each. To reward your bulk order, we are pleased to offer a 10% discount on the total. This brings your total to a rounded and friendly price, making it easier for your budgeting needs.",
                "job_type": "event manager",
                "order_size": "large",
                "event_type": "meeting",
                "order_date": "2025-01-01T00:00:00"
            }
        ],
        "quote_explanation": "The quote uses current catalog pricing for 3 matched item(s). Similar historical quotes were reviewed for consistency."
    },
    "timestamp": "2026-04-01T11:43:08.256339"
}

Docker

Next step is to dockerize the application but before that, I changed the use of a local SQLite database to using Postgres in production.

# Multi-stage build for Paper Supply Agent API
# Stage 1: Builder
FROM python:3.11-slim as builder

WORKDIR /build

# Install build dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    postgresql-client \
    && rm -rf /var/lib/apt/lists/*

# Copy requirements
COPY requirements-prod.txt .

# Create virtual environment and install dependencies
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
RUN pip install --no-cache-dir -r requirements-prod.txt

# Stage 2: Runtime
FROM python:3.11-slim

WORKDIR /app

# Install runtime dependencies only
RUN apt-get update && apt-get install -y \
    postgresql-client \
    && rm -rf /var/lib/apt/lists/*

# Copy virtual environment from builder
COPY --from=builder /opt/venv /opt/venv

# Set environment variables
ENV PATH="/opt/venv/bin:$PATH" \
    PYTHONUNBUFFERED=1 \
    PORT=8000

# Copy application code
COPY . .

# Create non-root user for security
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
    CMD python -c "import requests; requests.get('http://localhost:8000/health', timeout=5)" || exit 1

# Expose port
EXPOSE 8000

# Run application
CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "8000"]

Deployment Scripts

Third step is build deployment / destruction scripts for the required AWS services to be able to run them automatically from a Github action following this architecture:

We can run one service and when there is an increase in requests, we can add another container and route requests between the deployed containers. This was successfully deployed to AWS.

Github Actions

Final step is create a deploy / destroy workflows in Github Actions which can work manually or through pushing to the P05 folder. You can view the code here.

name: P05 Deploy

on:
  push:
    branches:
      - master
    paths:
      - "P05/**"
      - ".github/workflows/p05-deploy.yml"
  workflow_dispatch:

concurrency:
  group: p05-deploy
  cancel-in-progress: false

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      contents: read

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_REGION }}

      - name: Verify required secrets are set
        run: |
          set -euo pipefail
          test -n "${{ secrets.AWS_ACCOUNT_ID }}"
          test -n "${{ secrets.OPENAI_API_KEY }}"
          test -n "${{ secrets.DB_PASSWORD }}"

      - name: Make deploy script executable
        run: chmod +x deploy_aws_resources.sh
        working-directory: P05

      - name: Deploy app and infrastructure
        env:
          AWS_REGION: ${{ secrets.AWS_REGION }}
          AWS_ACCOUNT_ID: ${{ secrets.AWS_ACCOUNT_ID }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          DB_USERNAME: ${{ secrets.DB_USERNAME }}
          DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
          PROJECT_NAME: ${{ secrets.PROJECT_NAME }}
        run: ./deploy_aws_resources.sh
        working-directory: P05

And with that all learning objectives are now complete.

What do you plan to do this week?

I will extend the knowledge that I gained over the previous weeks to work on my capstone project for the remaining 4 weeks. I’ll probably be using LangChain, LangGraph and LangSmith to explore another multi-agentic building framework similar to the Hugging Face smolagents framework.

Are there any impediments in your way?

No, just some added pressure to finalize the final project for CSPB 3010 in addition to the capstone project here.

Reflection on the process you used last week — how can you make the process work better?

I’m really happy with the progress so far and how comfortable I was working with Github Copilot and making suggestions to update the codebase after setting the plan and reviewing the generated files.

Week 08 [Mar 9 - Mar 16, 2026]

What did you do last week?

Last week was quite busy, I managed to complete and submit the last project for the Udacity Agentic AI course and graduate. It did take sometime to complete but I’m happy to get exposed to what makes Agentic systems work.

The final project of the course is for the Beaver Choice Paper Company. The challenge is that the company is struggling with managing their paper supplies, responding promptly to customer inquiries, and generating competitive quotes. They’re overwhelmed and losing potential sales due to inefficiencies. We have to design and implement a multi-agent solution, restricted to at most five agents, capable of handling inquiries, checking inventory status, providing accurate quotations, and completing transactions seamlessly. The solution must ensure responsiveness, accuracy, and reliability in managing requests and maintaining optimal stock levels.

1. System Overview

   The system uses 5 agents built on the smolagents (ToolCallingAgent) framework to automate paper supply order processing. An LLM-based ParsingAgent handles natural language understanding, while business logic agents remain deterministic.

   

   Workflow Explanation & Design Rationale
   

   The architecture separates concerns into five single-responsibility agents, each owning one stage of the order pipeline:
   

   1. Orchestrator
   Acts as the central coordinator. It receives the raw customer request, delegates to each downstream agent in sequence, and assembles the final response. By keeping orchestration logic in a dedicated agent, the workflow is easy to modify (e.g., adding a new validation step) without touching individual agent implementations.
   

   2. ParsingAgent
   The only agent that relies on an LLM. Customer requests arrive as free-form natural language with varied phrasing (“500 sheets of glossy”, “10K A4”, “printer paper”). Rather than maintaining brittle regex patterns or synonym dictionaries, the system delegates parsing to an LLM that receives the full product catalog and returns structured item/quantity pairs. This design choice trades determinism for flexibility: the agent handles synonyms, abbreviations, and novel phrasing without

   code changes.
   

   3. InventoryAgent
   Performs deterministic stock and feasibility checks. For each parsed item, it queries the database to verify stock levels, checks whether the company’s cash balance supports a restock order, and compares supplier ETAs against the customer’s delivery deadline. Separating inventory logic lets it be tested and reasoned about independently.

   
   4. QuotingAgent
   Computes pricing using catalog unit prices and applies volume-based discounts. It also reviews historical quote data for consistency. Isolating quoting from ordering ensures that a quote can be generated and inspected before any money changes hands.

   
   5. OrderingAgent
   The only agent with database write access. It commits sale transactions and, if needed, stock replenishment orders. By restricting writes to a single agent, the system minimizes the risk of inconsistent state from partial failures.

   
   This sequential pipeline was chosen over a parallel or fully autonomous multiagent design because each step depends on the output of the previous one (you cannot quote items that haven’t been parsed, or finalize an order that hasn’t been assessed). The strict ordering also makes the system easier to debug failures can be traced to the exact stage that produced unexpected output.

2. Evaluation (Evals)

Here is the final workflow diagram for the multi-agent system

If you’re interested to review the code, then check this link.

In addition, I managed to review the additional learning resource requirement for the Github Actions certification from Linkedin and Microsoft Learn and successfully sat the exam.

What do you plan to do this week?

This week and upon the recommendation of Prof. Guinn, will deploy an AI agent to production. I have a rough plan of how to do that and will use the project I worked on in the Udacity course for deployment.

The plans is as follows:

• Open up an endpoint for my agentic system to receive customer requests. That can be done by using FastAPI.

• Dockerize the application and push the image to ECR (Amazon Elastic Container Registry)

• Create a running container from the stored image in ECS (Amazon Elastic Container Service)

• Build a Github Actions workflow to allow automated CI/CD

Are there any impediments in your way?

I got ahead of my initial plan to allow for more time to work on deployment and my personal project. In other words, a complete 4 weeks to complete my personal project.

Reflection on the process you used last week — how can you make the process work better?

With suggestions from Prof. Guinn and putting in more work this week, I believe that I can comfortably achieve my goals during the remaining 5 weeks.

Week 07 [Mar 2 - Mar 9, 2026]

What did you do last week?
Started Course #4 of the program. It is all about applying all the bits and pieces we learned in previous weeks into multi-agentic systems.

• First concept is about multi-agent architecture design and answering the following questions to carefully design multiple agents that can effectively work with each other:

  • Who does what? (What does each agent specialize in?)

  • How do they talk to each other? (directly or through a manager/orchestrator or not at all)

  • What are the rules of engagement? (solving for conflict and recovering from failures).

  • How do we save and manage the state of agents? and how does data flow from agent to agent?

• Second concept is the introduction of Smolagents as a multi-agentic framework.

  • It is a Python framework for building multi-agent systems powered by large language models (LLMs). It is designed to make it easy to create, orchestrate, and manage agents that can use tools (Python functions), maintain state, and collaborate to solve complex tasks.

  • Smolagents lets us build intelligent, tool-using, multi-agent systems with LLMs and Python, making it easy to combine language understanding with real-world actions and stateful workflows.

• Third concept is about organizing agents around an orchestrator that acts as a Project Manager that:

  • Delegates tasks to specialized agents providing them with the necessary information to do their job.

  • Handles response from the specialized agents.

  • Manages state (keeping track of program and retaining information)

  • Recovers from errors and failures.

• Fourth concept is handling routing between agents and how can that happen using:

  • Content based Routing: by looking at keywords or data types.

  • Round Robin Routing: Divide tasks equally usually among the same kind of specialized agents

  • Priority Based Routing: Check the priority of tasks and accelerate the execution of high priority tasks.

  In addition, we need to manage the data flow between agents especially if we are mixing structured and unstructured data together so that each agent can receive information in a format that it understands.

What do you plan to do this week?

This week, I intend to complete the fourth course with exploring the following three concepts:

• State Management in Multi-agentic systems and understanding the difference between conversation level state (short term memory) and system level state (long term memory)

• How do we coordinate state between different agents and the importance of the orchestrator to do that?

• How to use RAG to empower multiple agents to work together to solve complex tasks.

Are there any impediments in your way?

There shouldn’t be any problems or anticipated delays this week.

Reflection on the process you used last week — how can you make the process work better?

I put additional effort last week to keep on track and am planning to hopefully allocate some more time during Spring break to finish the course in order to spend more time on the capstone project.

Week 06 [Feb 23 - Mar 2, 2026]

Mid Project Update

My progress so far is going nearly as planned with a couple of days of delay so far which I anticipate being able to cover during Spring Break at the latest.

1. Learning Objectives

2. Completed Weekly Tasks

3. Remaining Weekly Tasks

4. Reflection

This project has been a good steppingstone into the world of Agentic AI. Although the progress of the field is phenomenal (with moltbots now on the loose); I believe I have understood the building blocks of AI Agents and am excited to apply all my learnings to the specified capstone project. Taking this course with the Intensive Programming Workshop is turning out to be a bit of a chore which is sometimes affecting my progress overall.

Week 05 [Feb 15 - Feb 23, 2026]

What did you do last week?
Completed course #3 as part of the Udacity Agentic AI course. The concepts are really interesting which involved:

• Function calling with tools which involves having the LLM trained to recognize function call requests in its prompt.

• Structuring output using Pydantic so that it can be easily validated.

• Modelling agentic workflows as state machines where each step execution has inputs that are processed to produce outputs (e.g. LLM processing, tool calling, termination, etc…)

• Short Term memory can be modelled as a collection of workflows that are available and fed back to the LLM during one session (each session would have multiple prompts/interactions)

• Sometimes the Agent needs to query updated (past its training data cutoff date) and unstructured data so it can use an API to execute searches on the web and return a structured output.

• Agents need to query data from databases such as SQL, NoSQL or vector databases. For SQL databases, the agent would have to convert text to SQL.

• Retrieval Augmented Generation (RAG) is an important framework to search relevant knowledges for specific and particular information. This is done by querying a knowledgebase first which doesn’t necessarily need to be a vector database like Pinecone or Chroma.

• Long Term memory is needed to personalize agents across sessions and there are three types:

  1. Semantic Memory: Facts and Knowledge
     Storing important facts like the user’s name for example that can be retrieved using similarity searches.

  2. Episodic Memory: Events and Experiences

     Provides few shot examples and summaries of previous interactions for how the agent dealt with similar cases before.

  3. Procedural Memory: Behavior and Patterns

     This allows the agents to adapt its rules and prompts to specific requests such as maintaining a certain tone of voice. So with each interaction, the agent adapts to its users.

• Finally, evaluating the Agent’s output for

  • Task Completion

  • Quality Control

  • Tool Interaction

  • System Metrics

  We can evaluate agents using:

  • Final Response Evaluation: After a task, look at the final output.

  • Single-Step Evaluation: Evaluate a single decision.

  • Trajectory Evaluation: Trace the entire path the agent took.

  So to build effective evaluation, we would need inputs, outputs, reference data and evaluators (such as LLM Judge for example)

What do you plan to do this week?

I intend on working on the third project which involves developing an assistant called UdaPlay. Executives, analysts, and gamers want to ask natural language questions like:

• Who developed FIFA 21?

• When was God of War Ragnarok released?

• What platform was Pokémon Red launched on?

• What is Rockstar Games working on right now?

The agent should:

1. Attempt to answer the question from internal knowledge (about a pre-loaded list of companies and games)

2. If the information is not found or confidence is low, search the web

3. Parse and persist the information in long-term memory

4. Generate a clean, structured answer/report

Are there any impediments in your way?

There shouldn’t be any problems or anticipated delays this week.

Reflection on the process you used last week — how can you make the process work better?

I was expecting a more detailed explanation and implementation of Anthropic’s Model Context Protocol (MCP) as a standard way to use external tools and APIs but the course glossed over it quickly and so will be looking to supplement my knowledge with more information.

Week 04 [Feb 8 - Feb 15, 2026]

What did you do last week?

I started with course #3 as part of the Udacity Agentic AI course. This course goes deeper into using tools, formatting structured output, interacting with databases, using RAG and adding short and long term memory support. I’m about 60% done with the nanodegree.

I managed to review the first part about utilizing tools and will be continuing with the course content today. Managed to squeeze some work in between my traveling last week and working on the large first project for the Intensive Programming Workshop.

I also managed to watch Ben Snyder’s AI talk and especially enjoyed the intersection of sociology with computer science which involves a lot of graph and network theory.

What do you plan to do this week?

I intend on completing the course videos and coding exercises to allow some time to work on the course project next week.

Are there any impediments in your way?

There shouldn’t be any problems or anticipated delays this week.

Reflection on the process you used last week — how can you make the process work better?

I would say reviewing and marking the tough weeks and adding a bit of buffer in beforehand. And putting the work in even for 20 or 30 minutes during the week regardless of other commitments to push forward a little during the tough weeks.

Week 03 [Feb 1 - Feb 8, 2026]

Last Week:
I worked on the second project in the Udacity Agentic AI course where I got into more detail about the different agentic patterns, including running agents in parallel or sequence, having an intelligent orchestrator to route prompts to the most relevant agent as well as study two agentic workflows:

1. The first being the evaluator-optimizer workflow where we using LLM judging to assess if the output of the LLM meets our passing criteria. if the evaluation fails, another iteration happens with feedback generated from the first failure fed back as a prompt to the workflow.

2. The second is the orchestrator-worker workflow where specialist agents handle very specific tasks and the orchestrator routes the tasks to their best agents before terminating with the final response. We should have tasks first and that’s where Chain of Thought is important to divide our prompt into actionable tasks.

This project is also really interesting and is based on setting up an agentic software project management workflow to help build a sprint backlog for development from a set of customer requirements.

Here’s an excerpt from the final result:

**Feature 1: Automated and Efficient Email Handling**

- **Task ID: T001**
  - **Task: Develop Email Response Automation Module**
  - **User Story Reference**: US001 - As a user, I want routine inquiries to be automatically handled so that I can focus on more complex tasks.
  - **Detailed Description**: Build logic to identify routine inquiries by analyzing email content patterns. Develop algorithms to generate automated responses using natural language processing. Integrate a library of standardized responses into the system to ensure consistency.
  - **Acceptance Criteria**: Routine inquiries are correctly identified and responded to with a 95% accuracy rate. Automated responses are generated within 2 seconds.
  - **Estimated Effort**: 40 hours
  - **Dependencies**: Completion of the standardized response library (T002).

- **Task ID: T002**
  - **Task: Design and Implement Standardized Response Library**
  - **User Story Reference**: US002 - As a user, I want a library of standardized responses to ensure consistent communication.
  - **Detailed Description**: Create a database to store common inquiries and responses. Develop a system for easy access and retrieval of these responses, ensuring they are up-to-date and relevant.
  - **Acceptance Criteria**: The library contains at least 100 standardized responses and can be accessed in under 1 second.
  - **Estimated Effort**: 30 hours
  - **Dependencies**: None

- **Task ID: T003**
  - **Task: Testing and Validation**
  - **User Story Reference**: US003 - As a user, I want to ensure the accuracy of automated responses to maintain customer satisfaction.
  - **Detailed Description**: Perform unit and integration testing to ensure response accuracy. Validate the consistency and accuracy of the automated responses through user testing and feedback.
  - **Acceptance Criteria**: Automated responses pass all test cases with a 95% success rate.
  - **Estimated Effort**: 20 hours
  - **Dependencies**: Completion of T001 and T002.

This is pretty amazing and I’m only using GPT-4o as the LLM processor.

So the project is in review and will keep you updated with the outcome.

You can check the source code for the second project here.

This Week:

I will start studying course #3 which is building agents with access to memory (short/long term), databases and tools.

Impediments:

I travelled to attend a startup conference in Dubai and although I finished the work a bit early, I couldn’t submit and provide my progress till today. I’m taking the intensive programming workshop too and we have a deadline for the first project next week which may slow down my progress a bit for professional development till I’m able to submit the project.

Reflections / Improved Process:

I’m still not sticking to a strict schedule but am doing fine up till now with my schedule being a bit fluid around priorities, work, life and other course requirements. I’ll be monitoring this closely to make sure I don’t slip on the way to the finish line.

Week 02 [Jan 26 - Feb 1, 2026]

• What did you do last week?
  I successfully completed Course #1 and passed the first project.

  

  One thing I really like about Udacity is that their projects are reviewed by humans to provide detailed feedback and code reviews (don’t know if they’re still using humans or have shifted to AI grading after the Accenture acquisition).

  

  I added the review above to summarize my takeaways from the lesson. Agentic AI is all about system design and less about actual machine learning. LLMs are treated as black boxes with prompts as inputs to the system and assistant responses as outputs. This distinction will become important in Course #2 as I work on workflow design.

• First step to optimize the system is to work on refining the input. In other words, how do we construct a good prompt?

  The course suggests to divide the prompt into 5 sections as follows:

  [Role]: The persona the LLM should adopt (e.g., “Act as a high school teacher.”).

  [Task]: The specific instruction or question (e.g., “find a solution to the following trigonometric identity.”).
  

  [Output Format]: How the response should be structured (e.g., “One sentence answer”).

  [Examples]: Sample input/output pairs

  (e.g., “Q: What is the value of

  A: It is 1”).

  [Context]: Additional information needed for the task (e.g., current date, if asking for the date).

• Use Chain of Thought (CoT), which is a process to divide tasks into smaller sized sub tasks executing one after the other. This is accomplished by explicitly mentioning in the prompt to “Reason step by step”.
  
  ChatGPT explains this quite well:
  CoT is the agent’s internal deliberation / scratchpad that helps it:

  • break a goal into steps (“what sub-problems do I need to solve?”)

  • choose the next action (“which tool/API should I call?”)

  • keep state (“what have I learned so far?”)

  • handle errors (“that tool failed—what’s the fallback?”)

• Insure that we specify a schema for the output and validate the output. This can be done by using Pydantic models and asserting if the LLM output adheres to the specified schema. Here is an example from the Pydantic documentation:

  

  and an output field can be verified by asserting the following:

  

  the model_validate() class function can be used as well to validate the LLM output against the schema.

• Use ReAct (Reasoning /Acting framework)

ReAct is a pattern where the LLM can alternate between thinking and taking actions:

1. Think: a step where an LLM can decide what’s missing and what to do next (e.g. “I need to get the current date to find suitable events”)

2. Act: perform an action or call a tool (e.g. “use tool get_current_date with no arguments“ )

3. Observe: Read the result and use it to choose the next step (e.g. “Today is February 4, 2026, now I can filter events for today.”)

4. Final Answer: This loop repeats until the model has enough information, then it produces a Final Answer.

The purpose is to reduce hallucinations by checking real world information.

I applied these concepts to a travel AI agent that plans a trip to the wonderful city of AgentsVille! You can check the code here.

• What do you plan to do this week?
  This week, I’ll be continuing with Course 2 from the Udacity Nanodegree looking at Agentic workflow patterns such as prompt chaining, parallelization and routing and then I’ll review two important agentic workflows:

  1. Evaluator-Optimizer workflow

  2. Orchestrator-Worker workflow
     

• Are there any impediments in your way?
  Currently no problems in sight.
  

• Reflection on the process you used last week, how can you make the process work better?

  To be truthful, I didn’t stick to my slotted time and had to delay it from my scheduled Friday sessions to the next available times on Monday and Tuesday when I reviewed the course content and completed the project on one day and then worked on my blog post and providing updates on the second. I still have my next scheduled session on Friday and I hope that I can stick to it this time. I feel that spacing out my work between sessions helps me process and recall concepts better.

Week 01 [Jan 20 - Jan 26, 2026]

I’ll be providing Agile style weekly standup updates and here’s the first one:

• What did you do last week?
  Last week was focused on narrowing my topic of interest and since I’m on a trajectory to develop my AI skills, I went for Agentic AI. It’s a trendy topic and I’d love to gain a better understanding.

  I’ve been experimenting with construction cost estimations on several projects using line item descriptions and a basic knowledgebase of two previously priced construction projects with chatGPT in Thinking mode (i.e. using agents) but with mixed results. Here’s a sample of a project that was recently estimated using AI agents vs a real cost estimator for mechanical works in a 5 stars hotel:

  

  I’m working on refining the AI system architecture for better use of short and long term memory as well as vector databases for Retrieval Augmented Generation (RAG). Therefore, I’ve identified the Udacity Agentic AI course as the source for my learning throughout the next 13 weeks.
  

• What do you plan to do this week?
  I’ve already started with the first module of the Udacity Agentic AI course and will be completing and submitting the first project this week. I’ll then be writing my first article summarizing my learnings from the week.
  

• Are there any impediments in your way?
  Currently no problems in sight.
  

• Reflection on the process you used last week, how can you make the process work better?

  I haven’t really tested the process last week but with the plan set in the proposal, I’ll be starting to time my commitment to the slotted weekly study time.

With work and life commitments, the plan is extended a bit. But I was able to adjust my planned courses to take Natural Language Processing (NLP) which is an important course for understanding Large Language Models (LLMs). I built a workflow to automate construction costing using n8n and an OpenAI GPT model which was fun and enriching.

In the Spring, I’ll start the Intensive Programming Workshop which is going to be a deep dive into Object Oriented Programming while working on a number of gaming projects.

Finally, the program cost breakdown is spread out now over 5 years. It’s difficult to register for more than one course per semester if I want to maintain a 4.0 GPA while being committed to my work and teaching.

In a previous post, I talked about automating the grading and feedback process in my teaching gig at the MIT professional education program. I successfully built my own AI grader and will be talking about that next.

• The rise of immersive virtual learning environments (i.e. AR/VR). An area well suited to train people without the need of using expensive equipment (e.g. plane simulators)

• AI driven adaptive learning. This is an area that Sal Khan (Khan Academy founder) is bullish about. Here’s his TED talk about the subject. Personalized one-on-one learning yields the best results but is the most expensive. So can we use AI to reduce the cost of personalization with AI tutors?

• Neurotechnology and accelerated Learning (i.e. the Matrix stuff) which is the next frontier in learning. Why need to spend years learning when you can just upload the knowledge to your brain through a brain implant. Neuralink (an Elon Musk company) is doing exactly that.

• Lifelong learning, where what you learn in college becomes irrelevant quickly and each one of us needs to get upskilled every couple of years. So learning becomes a continuous endeavor instead of a one time thing you do in your early twenties.

In Workforce Education: A New Roadmap, a book by Willian Bonvillian and Sanjay Sarma, they explain that education is becoming the differentiating factor in obtaining high income jobs and joining the upper middle class.

In the US and other places as well, the middle class is thinning out and society is becoming more polarized between the haves and have-nots. They argue that people should work on not being left behind by getting a college degree.

But the data shows that college enrollments in the US has dropped since its peek in 2010 most probably due to alternative education methods and people wanting to opt out from crippling student debt.

And the growth of wages has not matched increase in tuition creating a dilemma where studying liberal arts is becoming prohibitively expensive in comparison to STEM based education where most of the high wage jobs are now. So the message is loud and clear that it matters what you major in and that you have to upskill consistently to stay relevant.

Even in alternative education providers, for example MOOCs, the top companies including Udemy, Coursera, 2U (Edx) and Udacity are facing a lot of pressure and competition. None of them are profitable. Udacity recently sold to Accenture in a rumored $80 Million deal where it was once valued at $1 Billion and raised over $300 Million. All of them are battling each other for market dominance which will certainly create a blood bath of overspending and low product differentiation.

Corporate businesses are also taking things into their own hands with all major tech companies creating their own certifications and “professional” degrees adding more pressure on traditional 4-year degree colleges.

Alex Hormozi invested in Skool (an online community platform) seeing a trend of declining formal education verses growing alternative education routes (i.e. elearning) where skills can be learned directly from creators instead of waiting 4 years to see if you qualify to join the workforce.

Alex also mentioned the pros and cons of starting an education business and it’s interesting to hear his thoughts on the matter.

In The Abundant University: Remaking Higher Education for a Digital World, Michael argues that college professors are stuck with two things:

• Doing the bare minimum to teach because their primary job is research and not teaching.

• Being stuck explaining concepts, theories and ideas developed by others in the field. So students get this information second hand instead of hearing it directly from the source.

Coursera is taking a stab at this by making content creation stackable. They go and shoot videos with instructors explaining certain topics (which they’re the best at) and then add it to a digital library. As an instructor with Coursera, you can mix and match content to create courses to teach your students. Not a bad idea at all but certainly expensive and I bet Coursera is counting on the effect of compounding to grow this digital library.

Some other ideas from Workforce Education

1. Deliver material in bite sized chunks, be it videos or dripping content (which most course management platforms do now). For those of you that don’t know dripping, it’s the process of slowly opening content week by week as to not overwhelm the learner. The authors also make a case that Youtube is the greatest edtech platform out there right now.

2. Students don’t need just money to spend on education. They need career guidance and support systems to help them succeed. Cohort and live based learning has made a splash with most Executive Education programs being delivered digitally through cohorts and live sessions.

   If you read my previous post, I already teach two courses that are delivered that way. Maven is also the Udemy of cohort based live courses and Wes Kao (co-founder) is also pretty active writing online about the pros of such an approach.

3. New generations are quitting jobs twice as often as previous ones.

4. There are no good information systems that connect job seekers to jobs, identifying what skills they need to develop to qualify for the jobs and then suggest the best educational resources or credentials. A key takeaway is to develop better data on education, skill supply, and demand projections, on business expansion, and on overall workforce quality and needs.

5. Likewise, employers lack a solid way to evaluate worker qualifications. Whenever I post a software developer job on Linkedin, I get bombarded by thousands of applicants many are just not qualified. Recruitment agencies and freelancing platforms are sprouting out to do the assessment for companies (e.g. Toptal or Turing) and charge a premium.

6. Lifelong learning is a thing and it will become more and more important to stay relevant.

7. Some concepts to improve content include: learning by doing, flipped classroom, hands on learning, project based learning and integration across multiple silos and disciplines which give students more autonomy and purpose. Retrieval practice, spaced repetition and interleaving content (mixing multiple formats - audio, video and reading) are also important.

8. Desirable difficulty is when the learner is operating right on the frontier of their comfort zone. In other words, the content is not so difficult that they can’t figure it out or that it is too easy that get bored and distracted quickly.

9. Continuous assessments and feedback especially rich feedback is essential but hard to get. There are many different approaches to this:

   1. Peer grading. Learning happens when students are both writers and evaluators

   2. Automated grading through online quizzes and automatic code graders.

   3. Mentor based manual grading. Udacity has actual people look at your work (projects) and grade it. This is in my opinion is where the platform is vastly superior than any other.

   4. AI. LLMs show promise to provide detailed and personalized feedback.

   If you noticed from my first post here, most of my time is spent on grading and providing feedback.

10. Intelligent Tutoring Systems. The fancy word for AI tutors are the pinnacle of personalized learning. Bloom (yeah the one from Bloom’s Taxonomy) researched the issue and found out that one-on-one tutoring is vastly superior than the conventional classroom way of teaching. In fact, 2-sigma better which is now known as the 2-sigma problem.

11. Cognitive Load Theory which states that teaching beginners requires a lot more hand holding and as they become experts on the subject, more open-ended problems are suitable.
    

12. Gamification: the social aspect of learning, make it competitive to excite and motivate learners. The famous concepts of micro-learning and streaks popularized by Duolingo to help learners come back to the App.

13. Games and simulations are two important methods to teach skills. The more realistic the game or simulation (with real-time feedback), the more learning happens.
    

14. Collaboration tools such as Miro and Zoom as well as online communities (Circle, Piazza) enable continuous collaboration between teachers and learners.

15. Generative learning theory: states the learners get better when they generate new information based on well understood concepts. Teaching for example?

16. Digital skills are on the rise and all occupations are becoming less routine over time.

17. Mastery based learning is when students don’t move to another topic before mastering the current one that they’re studying which as you noticed above also yielded better results than conventional classrooms.

18. Micro-credentials are also enabling students to get accredited without attending college. These can be stacked to form degrees. But third party certification remains an important step to assess the quality of these credentials and certificates for employers.

So what are some cool ideas that maybe are worth exploring further?

• Games & Simulations as learning tools

• AI based rich feedback and grading

• Navigation tools connecting jobs (and trends) with skills and educational resources.

I have a lot to think about now. See you next week!

I need to make money and fast. What better way to look at a high level picture of the situation than checking Robert Kiyosaki’s cashflow quadrant. There are a total of four ways to make money.

Either being an employee (your manager is your boss) or being self-employed (your clients are your boss) and selling time for money. I am already working so I’m not looking to be employed yet again so the E quadrant is not for me. The S quadrant looks promising but I do need to optimize the Price / Time ratio. We’ll look at that in a bit.

Now being a business owner leverages other people’s time for money and if the system works (i.e. the company is profitable) you get an asset that can be sold later for anywhere between 2x to 10x of profits.

The downside is that you still have to pay money in terms of salaries, rent, software, tools and equipment to do anything meaningful. So there is a lot of overhead getting jobs or selling products and services as well as managing people. I don’t have that kind of time or patience so the B quadrant is out of the question.

The final quadrant is the investor quadrant, the holy grail of money making where your earnings are not directly linked to your time such as rent, stock dividends, royalties, ad revenues, affiliate commissions, etc…

Many assets in this quadrant are also appreciating so you can sell later for more than you initially invested in them. This promises to have the lowest time commitment for the highest returns. The problem is that it also takes a lot of time for the returns to materialize and so is not a fast way to earn additional income.

Therefore, I’m looking at something like this.

I’d probably start in the S quadrant (maybe doing some freelancing, consulting or contract work) but with something that maximizes my rate equation above either by increasing my price or lowering the time needed to do a good job and if both then that’d be fabulous. After that, I’d be slowly moving to the I quadrant. I’ll talk about how to do that in later posts.

So now I want to find my Ikigai (may be too much but it’s a cool concept that I’d like to mention here). Ikigai is a Japanese concept describing the things that make your life worthwhile and give you a deep sense of purpose, satisfaction and joy. It’s the intersection of what you love, what you are good at, what you can be paid for and what the world needs.

As Naval Ravikant once tweeted (which I am paraphrasing here) “Do what will feel like play to you and like work to others”. This has the advantage that you’d outwork everyone else because you won’t feel tired, bored or burned out which is a real problem in this day and age.

The hard part is finding an answer for each one of the Ikigai questions. This does need a bit of soul searching, here’s what I came up with answering these questions:

• What I love? teaching, learning, writing, swimming, going out with friends, having engaging conversations, walking, table tennis, traveling, science fiction, entrepreneurship and startups, sketching and coloring.

• What I’m good at? empathy, motivation and inspiration, electronics, coding, strategy, experimenting and solving problems.

• What I can be paid for? tutoring, coaching, coding, project management, product management.

• What the world needs? This is hard but I’d say that, better education (learning valuable skills) to get better opportunities (full-time jobs or starting businesses). In William and Sanjay’s book Workforce Education, they mention that having a college degree is the best indicator in the United States for getting better opportunities.

The sweet spot would be inspiring and teaching people valuable skills using technology. So, low risk, fun work, teaching and coaching others to improve their tech skills preferably in a live format. I had a chance to teach Udacity’s Intermediate JavaScript program in 2022 and really enjoyed the experience and so was searching for a similar remote opportunity.

I finally landed a remote teaching position at the intersection of entrepreneurship and technology with MIT Professional Education facilitating two of their courses and coordinating one of their professional certificates:

• Digital Platforms: Designing Two-Sided Markets from APIs to Feature Roadmaps

• Forecasting Technology Innovation Using Data for Strategic Advantage

• Professional Certificate Program in Industry 4.0

That was a great find and am really happy to be teaching again. Here’s my income from last year:

The question remains as how did I land a position at MIT professional education and I’ll leave Kaelyn to answer that because I had a similar experience and her episode with Ali Abdaal is more fun to watch.

Probably between teaching, grading and communicating with students, I ended spending around 250 hours last year. So my rate was around $54 an hour. I did have a lot of fun teaching and prepping but grading was a real chore. Oh, by the way, I reached the target with a surplus of $2,000. That’s cool!

Now to improve my rate and gain some lost time. I need to either raise my prices which I doubt is possible or reduce the number of hours spent. That’s possible! I believe I can have that down to less than 100 hours. The bare minimum is 64 hours which are the number of live sessions that I have to be part of.

So can I reduce 186 hours spent grading to 36 hours without reducing the quality of feedback? thus raising my rate to $135 an hour and gaining some valuable time to put in learning, family or fun.

I have an idea how but that’s the topic for another post so stay tuned. 😉

The rules still apply:

• Must be part-time and remote.

• Should be from reputable institutions.

• Fully funded through scholarships or side hustles. No debt!

• Achieve a reasonable work-study-life balance (if that’s even possible).

• Document the skills and lessons I learn along the way.

Since I won’t be applying for a Masters or PhD programs anytime soon, I’ll differ talking about them till then.

Step #1: Pivoting into Computer Science

Since I already have a degree in electrical engineering, have been programming on and off for sometime and went through two bootcamps in web development from Bloomtech and data science from Coding Dojo so have a good grasp of multiple programming languages.

I only needed to get up to speed with C.S. courses. So ideally, a specialized fully online program preferably from a US institution that can issue credentials easily transferable to a graduate degree. I found two which have been around for sometime. The first from Colorado Boulder and the other from Oregon State. Since I was familiar with Colorado Boulder and their undergraduate degree program in computer science was ranked in the top 30 to 40 in the U.S, this looked like a good first step.

I applied to the University of Colorado Boulder’s Postbaccalaureate BS in Applied Computer Science which is identical to their on-campus program but fully remote and takes into account previous undergraduate study and I got-in in June 2023 after sitting the ALEKS placement exam (high school level math exam) and the TOEFL (English language proficiency test) online and from home.

Yay! I was in. Now the hard part. Putting a plan in place. I searched reddit to get an overview of the program and what to expect. I found a very good post about this from a graduate who recently completed the program. It was enlightening especially understanding the time requirements of the program (or in other words, what I can handle and afford). Officially, the school has the following list which I found helpful to compare courses against each other but not in absolute number of hours spent on a course which varies considerably from student to student.

Financially, this is not cheap too. I have to take 45 credits to graduate. Being an international student would cost me more at about $906 per credit and so $40,770 in total. After processing fees and the cost of textbooks, we’re up to $46,000.

I’m not in a hurry to complete the program and am targeting mastery of the material instead of just competency. Therefore, one heavy load course or two medium load courses maximum per term was a good trade-off between work-load and expenses.

So, I set up a plan to complete the program in 3.5 years. I’m in my third course now (CSPB 2270) and managed to get a A on both CSPB 1300 and CSPB 2824.

Expenses are distributed on the total length of the program and so I’m expected to pay around about $12,000 every year on average.

Based on all that, I need to dedicate about 10 hours weekly to study and come up with an extra $12,000 yearly to pay for tuition. So first two rules are done. Now I need to cough up the money to fund this endeavor and learn a few things on the way.