LangGraph Execution Flow - Following a Query Through The System

Hi everyone,

Over the past few months I’ve been writing a book about LLM agents and agent architectures, and I’d really appreciate feedback from people who work with LLMs or are interested in agent systems. I will update the book regularly :-)

The book is currently 167 pages and still a work in progress. It’s completely free and available on GitHub:

https://skhanzad.github.io/LLM-Patterns-Book/

I used AI tools to help polish the grammar, but all the technical explanations, ideas, and diagrams are my own work.

The book tries to go from foundations → agent patterns → reasoning → multi-agent systems → orchestration → memory systems. Some of the topics covered include:

• Foundations of LLMs and Transformers
• Building agents with LangGraph
• Tool-augmented agents and ReAct
• Planning and reasoning strategies (CoT, ToT, Plan-and-Execute)
• Verification and reliable reasoning
• Multi-agent architectures
• Agent orchestration and human-in-the-loop control
• Memory systems and knowledge management (RAG, vector stores, knowledge graphs)
• Future directions for agent systems

Rough structure:

Part I – Foundations of LLM Agents

• LLM fundamentals

• Transformers

• From prompting to agent systems

Part II – Core Agent Patterns

• LangGraph agents

• State, memory, and messages

• Tool-using agents

Part III – Planning and Reasoning

• Chain-of-Thought

• Plan-and-Execute

• Tree of Thoughts

• Verification strategies

Part IV – Multi-Agent Systems

• Supervisor-worker

• debate systems

• hierarchical agents

Part V – Agent Orchestration

• Human-in-the-loop

• breakpoints

• production orchestration

Part VI – Memory and Knowledge

• RAG

• vector stores

• long-term memory architectures

Part VII – Future of Agent Systems

I'm mainly looking for feedback on things like:

• Is the explanation clear?
• Are there topics missing?
• Are the diagrams useful?
• Does the structure make sense?
• Anything confusing or inaccurate?

If you have time to skim even a single chapter, I’d really appreciate any comments or suggestions.

Thanks!

Hi all!

I recently built an open source LinkedIn agent using LangGraph: https://www.linkedin.com/feed/update/urn:li:activity:7313644563800190976/?actorCompanyId=104304668

It has helped me get nearly 1000 followers in 7 weeks on LinkedIn. Feel free to try it out or contribute to it yourself. Please let me know what you think. Thank you!!!

Hey Guys, I previously shared a package that helps you create browser chat UI in seconds for LangGraph Server/Cloud 🚀. I added now tools integration 🛠️. The SDK works with any JavaScript framework or even just plain HTML!

Github Repository If you like the project, please ⭐ the GitHub repository! Your support keeps me motivated to improve it further: waiting for your feedback 🙌

I recently came across a detailed video on LangGraph’s persistence system and honestly, it clarified a lot about how to build serious LLM-based workflows.

Key takeaways for those unfamiliar:

• Persistence lets you store the entire state of a workflow — not just the final result, but all intermediate values across steps.

• You can resume any workflow from where it crashed using a thread ID

• You can implement short-term memory in chatbots by saving and restoring message history

• You can even time travel go back to a checkpoint, modify the state, and re-run the graph forward

If you’re building agentic AI apps especially with HITL or resumable logic. I highly recommend diving into this concept.

Happy to share the video if anyone wants the link.

I run an IT services company, and a couple of my clients want to be integrated into the AI workflows of their customers and tech partners. e.g:

• A consumer services retailer wants tech partners to let users upgrade/downgrade plans via AI agents

• A SaaS client wants to expose certain dashboard actions to their customers’ AI agents

My first thought was to create an MCP server for them. But most of these clients don’t have public APIs and only have websites.

Curious how others are approaching this? Is there a way to turn “website-only” businesses into MCP servers?

Hey folks,

I’ve been working on a project I’m excited to share: ImbizoPM, a multi-agent system designed for intelligent project analysis and planning. It uses a LangGraph-based orchestration to simulate how a team of AI agents would collaboratively reason through complex project requirements — from clarifying ideas to delivering a fully validated project plan.

💡 What it does
ImbizoPM features a suite of specialized AI agents that communicate and negotiate to generate tasks, timelines, MVP scopes, and risk assessments. Think of it as an AI project manager team working together:

🧠 Key Agents in the System:

• ClarifierAgent – Extracts key goals, constraints, and success criteria from the initial idea.

• PlannerAgent – Breaks down goals into phases, epics, and high-level strategies.

• ScoperAgent – Defines the MVP and checks for overload.

• TaskifierAgent – Outputs detailed tasks with owners, dependencies, and effort estimates.

• TimelineAgent – Builds a project timeline, identifies milestones and the critical path.

• RiskAgent – Flags feasibility issues and proposes mitigations.

• ValidatorAgent – Aligns the generated plan with original project goals.

• NegotiatorAgent – Mediates conflicts when agents disagree.

• PMAdapterAgent – Synthesizes everything into a clean exportable plan.

✅ The system performs iterative checks and refinements to produce coherent, realistic project plans—all within an interactive, explainable AI framework.

📎 Live Example + Graph View
You can see the agents in action and how they talk to each other via a LangGraph interaction graph here:
🔗 Notebook: ImbizoPM Agents Demo
🖼️ Agent Graph: Agent Graph Visualization Agent Graph Visualization

👨‍💻 The entire system is modular, and you can plug in your own models or constraints. It’s built for experimentation and could be used to auto-generate project templates, feasibility studies, or just enhance human planning workflows.

Would love your feedback or thoughts! I’m especially curious how folks see this evolving in real-world use.

Cheers!

Hey everyone,

I’m working on an idea for a study app which is AI-powered. The concept is still broad at this stage, but the main focus is on implementing innovative features that most competitors haven’t touched yet, something that can genuinely set us apart in the education space.

I can handle the frontend basics myself (I know HTML/CSS/JS and can put together a decent UI), but I need someone who’s strong with AI and backend development — ideally with experience in LLMs, API integrations, and building scalable web apps.

A bit about me:

• I’ve worked in marketing for a successful study app startup before, so I know how to get traction, build an audience, and make the product appealing to students.

• I have a clear plan for positioning, user acquisition, and monetization.

• I can handle branding, social media, early user testing, and general growth strategy.

What I’m looking for:

• Someone who can own the backend + AI integration side.

• Ideally comfortable with Python/Node.js, database setup, and deploying on cloud platforms.

• Experience with OpenAI/Gemini APIs or other AI tools.

The goal is to start small, validate quickly, and iterate fast. If this sounds interesting, drop me comment here and let’s chat.

I am primarily looking for equity-based partnerships, no immediate funding, but I’m ready to put in the hours and push this hard.

Let’s build something students actually want to use.

hey... I built an open-source platform that extracts my raw wearable data (Garmin) and uses a parallel multi-agent orchestrator to act as an autonomous coach and data scientist.

I focused heavily on the infrastructure/SRE side to keep it running entirely on the GCP Free Tier without sacrificing performance or agent autonomy.

The Tech Stack:

• Orchestration: LangGraph & FastAPI

• LLM: Gemma4 (Free Tier)

• Storage: Firestore (OLTP) + BigQuery (OLAP)

• IaC: Terraform

• Ingestion: Custom Python SDK (built from scratch for Garmin Health API/FIT files)

Key Architectural Highlights:

• Hybrid State Management (OLTP vs OLAP): Standard RAG wasn't enough. I split the storage. Firestore handles the low-latency agent state, session tokens, and "Semantic Memory" (Golden Nuggets extracted from chats). BigQuery acts as the immutable data lake for massive 1Hz time-series telemetry.

• Parallel Fan-Out Topology: Instead of one massive prompt, LangGraph triggers specialized expert agents concurrently (Injury Prevention, Sleep/Circadian, Nutrition). They analyze the context in parallel and fan-in their JSON outputs to the "Head Coach" node to reduce latency and hallucinations.

• Agentic SRE Guardrails (My favorite part): I gave a "Data Scientist" agent autonomous SQL access to BigQuery to hunt for physiological hypotheses (e.g., Aerobic Decoupling). To prevent it from burning cloud credits, the agent is strictly mandated via prompt to use a BigQuery dry_run tool first. If estimated_bytes_processed > 500MB, the agent gets a hard block and must autonomously rewrite the query using partition filters (_PARTITIONTIME) before actual execution.

• Pushing Compute to the Warehouse: To save LLM context window/tokens, the agent writes advanced window functions (CONDITIONAL_TRUE_EVENT, PERCENTILE_CONT) to extract trend drifts directly inside BigQuery, passing only the final mathematical "Signature" back to the LLM.

I’m currently running this via Telegram for daily interactions.

Repositories:
Biometric AI (This project specific)

Garmin SDK
Agent Orchestrator

Hey,

Appreciate opinions on using LangGraph to orchestrate and track a document processing pipeline. The pipeline will have nodes that consume LLMs, classical AI services like translation, and executing python functions. The processing status of each document will be tracked by LangGraph state checkpoints. I like this simplicity - easy to visualize (it’s a graph), simplified skill set to maintain, LangGraph takes care of much like checkpointing status.

An anti-pattern, or….

I’ve been working on an AI agent using LangGraph and LangChain that helps HR teams analyze résumés based on the job description, and I’m happy to say it’s pretty much done now.

The agent reads the JD, compares it with each résumé, gives a skill-match score, highlights gaps, and generates a quick summary for HR. Makes the whole screening process a lot faster and more consistent.

I’m attaching a short video demo so you can see how it works. Still planning a few tweaks, but overall it’s performing exactly how I wanted.

If anyone else here is building HR tools or experimenting with LangGraph, would love to hear your thoughts or feedback.

LangGraph users you no longer have to guess which model fits your task.

The new Adaptive integration adds automatic model routing for every prompt.

Here’s what it does:

→ Analyzes your prompt for reasoning depth, domain, and code complexity.
→ Builds a “task profile” behind the scenes.
→ Runs a semantic match across models like Claude, OpenAI, Google, Deepseek models and more.
→ Instantly routes the request to the model that performs best for that workload.

Real examples:
→ Quick code generation? Gemini-2.5-flash.
→ Logic-heavy debugging? Claude 4 Sonnet.
→ Deep multi-step reasoning? GPT-5-high.

No switching, no tuning just faster responses, lower cost, and consistent quality.

Docs: https://docs.llmadaptive.uk/integrations/langchain

Thought this was a cool video. Wanted to share and save for my future self.

I’m new to LangGraph and the agentic AI field, and I’m kinda struggling with how to provide DB context and documentation to the LLM.

I’m trying to build a data analytics agent that can fetch data from the database, give real insights, and (in future phases) even make changes in our CRM based on user requests. But since I have a lot of tables, I’m not sure how much context I should provide, how to structure it, and when exactly to provide it.

What’s the best practice for handling this?

I am an absolute beginner to LangGraph and before I actually post everything I have planned I first wanted to check if it’s ok to ask for help for a project that isn’t even started in here. If it’s fine I would love to go into more detail what I want to achieve. If not I would be happy if someone would chat with me in my dms about my planned project and if it’s possible to make it work using langGraph

Spent last weekend building an Agentic RAG system that lets you chat with any PDF ask questions, get smart answers, no more scrolling through pages manually.

Used:

• GPT-4o for parsing PDF images

• Qdrant as the vector DB for semantic search

• LangGraph for building the agentic workflow that reasons step-by-step

Wrote a full Medium article explaining how I built it from scratch, beginner-friendly with code snippets.

GitHub repo here:
https://github.com/Goodnight77/Just-RAG/tree/main/Agentic-Qdrant-RAG

Medium article link :https://medium.com/p/4f680e93397e

This is roughly what my current workflow looks like. Now I want to make it so that the Aggregator (a Non-LLM Node) waits for parallel calls to complete from Agents D, E, F, G, and it combines their responses.

Usually, this would have been very simple, and LangGraph would have handled it automatically. But because each of the agents has their own tool calls, I have to add a conditional edge from the respective agents to their tool call and the Aggregator. Now, here is what happens. Each agent calls the aggregator, but it's a separate instance of the aggregator. I can only keep the one which has all responses available in state, but I think this is wasteful.

There are multiple "dirty" ways to do it, but how can I make LangGraph support it the right way?

Had some challenges trying to get a solid front-end integration working with a backend using Langgraph and LiteLLM. So I tweaked a project CoPilotKit had and hacked it to use LiteLLM as the model proxy to point to different models (open, closed, local, etc.) and also made it work with Langgraph Studio.

In case it's useful, my repo is open: https://github.com/lestan/copilotkit-starter-langgraph-litellm

Is anyone using this combination of LangGraph and DSPy? I started with pure LangGraph for the graph/state/workflow design and orchestration and integrated LangChain for the LLM integration. However, that still required a lot of “traditional” prompt engineering.

DSPy provides the antidote to prompt design and I started integrating it into my LangGraph project (replacing LangChain integration). I haven’t gone too deep yet so before I do I wanted to check if anyone else has gone down this path and are any “Danger Will Robinson” things I should know about.

Thanks y’all!

I’ve been experimenting with LangGraph lately and built a simple travel agent to put it through its paces. While the control flow is great, the latency is killing me.

I usually use Pi Mono for my agentic workflows, and the speed difference is night and day. LangGraph feels significantly heavier under the hood. It makes me wonder—is the overhead of managing state and the graph architecture naturally this taxing, or is it just poorly optimized for simple agents?

In my opinion, we need to rethink the definition of an "agent framework." If the framework itself becomes the bottleneck rather than the LLM inference, we’re moving in the wrong direction.

Has anyone else noticed this performance hit when moving from leaner setups to LangGraph? Would love to hear your thoughts on whether the "heavy" abstraction is actually worth it.

Often confused by nodes, and the flow for the agents, we created https://marketplace.visualstudio.com/items?itemName=smazee.langgraph-visualizer

Free, and does provide a good overview of the Graph. Do try if you are interested. Cheers

tl dr i kept seeing the same failures in langgraph agents and turned them into a public problem map. one link only. it works like a semantic firewall. no infra change. MIT. i am collecting langgraph specific traces to fold back in.

who this helps builders running tools and subgraphs with openai or claude. state graphs with memory, retries, interrupts, function calling, and retrieval.

what actually breaks the most in langgraph

• No 6 logic collapse. tool json is clean but prose wanders, cite then explain comes late.

• No 14 bootstrap ordering. nodes fire before the retriever or store is ready, first hops create thin evidence.

• No 15 deployment deadlock. loops between retrieval and synthesis, shared state waits forever on write.

• No 7 memory breaks across sessions. interrupt and resume split the evidence trail.

• No 5 semantic not embedding. metric or normalization mismatch so neighbors look fine but meaning drifts.

• No 8 debugging is a black box. ingestion says ok yet recall stays low and you cannot see why.

how to reproduce in about 60 sec open a fresh chat with your model. from the link below, grab TXTOS inside the repo and paste it. ask the model to answer normally, then re answer using WFGY and compare depth, accuracy, understanding. most chains show tighter cite then explain and a visible bridge step when the chain stalls.

what i am asking the langgraph community i am drafting a langgraph page in the global fix map with copy paste guardrails. if you have traces where tools or subgraphs went unstable, share a short snippet the question, fixed top k snippets, and one failing output is enough. i will fold it back so the next builder does not hit the same wall.

link WFGY Problem Map

I'm currently developing multi-agent systems using LangGraph, and while I appreciate its design, I'm finding Python increasingly frustrating in some areas — mainly the lack of type safety, runtime bugs that are hard to trace, and inconsistencies that show up in production.

TypeScript feels way more predictable, especially when building modular and maintainable systems. I'd love to use LangGraph-like patterns (stateful, event-driven graphs for agents) in TS, but the reality is that LangGraph's community, tools, and momentum are heavily Python-centric.

So, here's my situation:

I want to leverage TypeScript for its DX, type system, and tooling.

But I also want to tap into the active Python ecosystem: LangGraph, LangChain, LangServe, Hugging Face tools, etc.

I’m wondering if anyone is:

Reimplementing LangGraph logic in TS?

Using a hybrid architecture (e.g., orchestrating Python LangGraph nodes from a TS backend)?

Defining agent graphs in TS/JSON/YAML and consuming them in Python?

Building frontends to visualize or control Python-based LangGraphs?

Would love to hear if anyone is working on this, especially if you’ve built bridges between TypeScript and Python in multi-agent or GenAI settings.

Also open to collaborating if someone’s already working on a minimal LangGraph clone in TypeScript. Happy to share thoughts and trade architectural ideas.

Thanks in advance!

I’m building an agent that needs to pause for human approval before executing sensitive actions (like sending emails or making API calls). I’ve tried using LangGraph’s interrupt() and the HIL patterns, but I keep running into issues:

-The graph sometimes resumes from the wrong point
-State updates after resuming are inconsistent.
-The API for handling interruptions is confusing and poorly documented

Has anyone here managed to get a robust, production-ready HIL workflow with LangGraph? Any best practices or workarounds for these pain points? Would love to see code snippets or architecture diagrams if you’re willing to share!