An agent framework is useful when an AI must perform several tasks and make decisions through different roles, rather than answer a single question like a chatbot.
2
Annie uses LangGraph to build a passive-aggressive budget coach that reads transaction data, analyzes spending against a monthly budget, and sends an alert when spending reaches 80 percent.
3
The prototype uses Plaid's sandbox data, a LangGraph workflow, and a Streamlit interface, with future work around human-in-the-loop features and deployment beyond a local machine.
Summary
Annie explains how to choose a problem for an AI agent and walks through building a budget coach with LangGraph. She starts with LangGraph Academy's free Intro to LangGraph course, recommending Modules 1 through 4 to learn about state, memory, and human-in-the-loop features. She then adapts the course's research assistant example, reusing its node and edge structure for an agent that reads credit card transactions, analyzes them against a monthly budget, and produces sarcastic feedback. The implementation uses Plaid's sandbox and Python library to retrieve fake transaction data, then runs the workflow in LangGraph Studio. A Streamlit app provides an interface and sends an email alert when spending reaches 80 percent of the budget. The tutorial gives beginners a concrete pattern to copy, while also showing the limits of a local prototype and the next areas to develop.
An agent needs a problem with several decisions and tasks
Annie says the first step is finding a problem that actually requires an agent framework. A chatbot can answer a question on the fly, but an agent is useful when the work involves several tasks and decisions. The AI receives specific roles, and those roles make decisions at different points in the workflow. Retrieval-augmented generation and chatbots can still be part of the system, but the roles and their decisions are what make the framework useful for this kind of application.
LangGraph gives the workflow a graph and fine-grained control
Annie chooses LangGraph because it uses a graph-based approach to orchestrate workflows. She also values the fine-grained control it gives over the agent and the path toward an agent that can be deployed. Her first step is learning the framework through LangGraph Academy's free Intro to LangGraph course. She recommends Modules 1 through 4 because they build on one another and introduce state, memory, and human-in-the-loop features.
The research assistant example provides reusable agent structure
Annie recommends the research assistant in Module 4 as a foundation for a new agent. The example sets up assistants and experts that interview each other about topics and then write an academic paper. After reviewing the code, she reuses especially the parts that create nodes and edges. This gives her a clear structure to adapt instead of starting with an empty project, while also making the agent's code easier to understand.
A private data source makes the budget coach a real agent problem
Annie wants the project to do more than answer a simple prompt, so she chooses her credit card data as a source that is not publicly available or part of the model's training data. She also gives the project a playful purpose: a passive-aggressive budget coach. The agent reviews her purchases and comments on them. With help from Cursor, she changes the research assistant code into a workflow focused on personal budgeting.
The budget coach turns transactions into an alerting workflow
The agent has nodes for retrieving transaction data, analyzing it, and interacting with a budget coach through language models. Its tasks are to pull transactions, compare them with a monthly budget, and produce snarky comments about the current spending. Annie then connects the nodes and edges so the workflow analyzes transactions, generates a summary, and sends an alert. The alert is triggered when spending reaches a chosen percentage of the monthly budget.
LangGraph Studio lets Annie view the structure of the budget coach as a graph. The displayed workflow starts by analyzing transactions, generates a summary, and then ends, with an alert sent when the condition is met. In her example, the condition is reaching 80 percent of a monthly budget. This view gives her a way to inspect how the workflow moves from one operation to the next.
Plaid's sandbox supplies credit card data without exposing real accounts
Because credit card companies do not provide individuals with direct APIs for their data, Annie uses Plaid to connect to an account and retrieve statement data. Plaid has a Python library for this process and provides separate sandbox and production keys. The tutorial stays in the sandbox, which contains fake credit card data, so Annie does not expose her own financial information. A script retrieves transactions from the past 30 days and categorizes them from their descriptions.
The Streamlit prototype makes the agent usable and leaves room for human input
Annie puts the budget coach behind a Streamlit application so she can interact with it locally and explore human-in-the-loop behavior. The app displays a spending summary, sends an email alert, and returns sarcastic comments about purchases, such as the example involving a $300 pair of sneakers. She plans to use more of LangGraph's human-in-the-loop features, experiment with changing states, and deploy the agent somewhere beyond her local machine. She then encourages viewers to adapt the tutorial code for their own first-agent prototype.
"My next steps for this agent would be to use more of the human in the loop features that LangGraph offers to just play around with changing states and also to deploy it on more than just a local machine."09:48
Who should watch
You are new to AI agents and need a concrete project that shows how roles, state, nodes, and edges fit together.
You want to adapt an existing LangGraph example instead of designing an agent workflow from scratch.
You are prototyping an agent that needs private data, a user interface, alerts, or future human-in-the-loop interaction.
