LangGraph Agents: Implementing Human-in-the-Loop with User Feedback

The first multi-agent architecture is a single agent (count=1) that can connect to multiple tools and solve problems. The second architecture uses a single agent with multiple skill files, where each skill file packages experience and prompts for a specific domain (e.g., development vs. content). The third architecture, the supervisor pattern, uses one agent as a supervisor that receives questions, routes them to appropriate specialized agents, and collects responses. This mimics organizational structures where managers coordinate between team members. The supervisor architecture is suitable when you have multiple domains and specialized agents, allowing you to route questions internally without exposing specialized agents directly to users.

When context windows grow large, single agents become overwhelmed and lose focus. Multi-agent architectures create specialized agents (security, coding, Jira) with a judge agent combining results into coherent outputs. Kodo's architecture uses a context collector that bifurcates information to specialized agents, then a judge agent evaluates relevance against PR history and organizational guidelines. Agents communicate through prompt refinement where results create refined prompts for subsequent agents. Calibration uses PR history to guide agents on organizational priorities, since LLMs don't inherently understand industry-specific needs. The system indexes past PRs to identify similar issues. To resolve the U-curve problem, only the most important context is provided to each specialized agent. Multiple context sources (PR history, compliance documents) can be weighted differently. Dynamic weighting adjusts recommendations based on developer feedback—accepted suggestions receive higher weight, rejected ones receive lower weight, creating a learning system that adapts to organizational preferences.

ForestSwarm is a multi-agent system architecture that dynamically routes tasks to the most specialized agent using cosine similarity-based routing, enabling efficient collaboration across specialized agents in domains like healthcare diagnosis and financial trading.

AI workflows implement hierarchical delegation where higher-level agents assign tasks to specialized agents. This enables efficient parallel processing while maintaining coordination. The system tracks issue status through different states including active, blocked, and completed. Human approval integration pauses workflows until human confirmation is received, ensuring oversight while maintaining automated efficiency. Handoff mechanisms transfer completed tasks to other agents for continued processing, enabling seamless progression through complex workflows.

A multi-agent system uses a central routing agent that directs user queries to specialized sub-agents based on subject matter. Each sub-agent handles specific tasks like scheduling, exam inquiries, or general knowledge. The system uses webhooks to transfer information between agents, with each tool having its own webhook endpoint. The main agent receives the user's query, determines which specialized agent should handle it, and routes the request accordingly. This architecture allows for more precise and efficient handling of different types of queries while maintaining a unified user experience. The routing agent uses examples in its prompt to improve accuracy in directing queries to the appropriate specialized agent.

This comprehensive segment covers the end-to-end workflow for building, deploying, and managing LangGraph-based LLM agents on LangGraph Cloud. The process begins with designing an enhanced agent using GPT-3.5 Turbo with four external tools: web search (DuckDuckGo), math computation (Wolfram Alpha), image generation (DALL-E), and Python execution (REPL). The agent is configured using the ReAct framework for Chain of Thought reasoning. Deployment requires three files: agent.py, langgraph.json, and requirements.txt, uploaded to a GitHub repository. The deployment process involves configuring environment variables for API keys, selecting deployment tier (Development or Production), and waiting for automated build and deployment. Local testing uses Docker and curl commands. Post-deployment, LangSmith provides visualization of agent execution paths, thread management for conversation history, and comprehensive monitoring metrics including LLM call success rates, latency, and token usage. The deployed agent exposes API endpoints for integration with custom interfaces.

Checkpointing enables LangGraph agents to survive crashes, restarts, and interruptions by persisting workflow state externally. For demonstration, use MemorySaver; for production, implement PostgreSQL-backed checkpointing with langgraph.checkpoint.postgres.PostgresSaver. Create config objects with thread IDs to uniquely identify conversation sessions. When running agents, pass both initial state and config objects. This persistence allows resuming exactly where workflows left off, even after page refreshes or system restarts. Combined with streaming capabilities for real-time monitoring, this creates reliable production agents suitable for enterprise environments requiring robustness and traceability.

LangGraph Cloud enables developers to deploy AI agents as cloud-based API endpoints by creating a structured application with agent.py (defining AI agents using models like Claude 3.5 Sonet and tools like Tly Search), requirements.txt (listing dependencies), and lang.json (configuration), then testing locally with LangGraph CLI, deploying via LangSmith by linking a GitHub repository, and integrating with applications through Chainlit for user interfaces, providing full visibility into agent interactions and tool usage through monitoring dashboards.

This section covers the deployment and management of Google ADK agents on LangSmith's managed infrastructure. It includes testing agents in LangSmith Studio with chat mode and trace viewing, deploying agents using the uv run langgraph deploy command, and accessing deployment features including threads, cron jobs, stateless runs, A2A protocol, and MCP. The section demonstrates how deployed agents maintain persistence across sessions, allowing continued interaction with task information retained between user interactions. It highlights the benefits of managed deployment including built-in streaming, tracing, and production-ready API endpoints.

This tutorial demonstrates how to deploy LangGraph AI agents to the cloud using Render as a Platform-as-a-Service (PaaS), involving creating a Dockerfile with the LangGraph CLI, publishing the repository to GitHub, setting up a Redis key-value store for caching, and deploying the LangGraph server as a web service with environment variables for database connections and Redis URI. The deployment enables state management, streaming responses, and persistent conversation history through the LangGraph server API, which handles complex infrastructure concerns like state persistence and caching automatically.

Two main patterns exist for integrating agents with user interfaces: (1) Foreground tasks - maintain an open connection while the task runs, streaming events back to the frontend in real-time; (2) Background tasks - make a POST request to start the task and immediately disconnect, with updates pushed to the frontend through a separate events endpoint. The background pattern allows users to close the interface and return later to see completed tasks, enabling non-blocking user experiences where agents work independently while users continue other activities.

The five core building blocks of agent user interaction are demonstrated through practical examples. Chat interface functions as Slack for human-agent collaboration, with Copilot Kit providing headless UI and pre-built React components. Human-in-the-loop enables agents to present plans for user review, supporting both in-chat and out-of-chat variants with customizable JSON inputs and outputs. Generative UI renders agent state in real-time, keeping users engaged and enabling agent steering when execution goes off-track. Shared state synchronization enables bidirectional updates between frontend applications and backend agents, demonstrated through a recipe builder application where edits in the frontend immediately update agent state. Predictive state updates allow incremental content generation with user intervention mid-process, shown through story generation where agents write content progressively and users can edit character names or attributes. A research canvas application demonstrates combining multiple building blocks: generative UI for search progress visualization, shared state for maintaining research structure, and human loop for destructive operations like resource deletion.

Human-in-the-Loop (HITL) is an essential approach in agentic AI systems where humans actively participate at critical decision points to supervise, approve, correct, and guide model outputs, addressing two primary challenges: system reliability (since current LLMs are imperfect and may misinterpret queries or hallucinate) and accountability (since AI systems cannot be held responsible for errors). HITL improves accuracy, safety, and ethical alignment in AI applications. Common HITL patterns include action approval (requiring human confirmation before executing critical actions like payments or file deletions), output review and editing (human review of generated content before publication), ambiguity clarification (resolving unclear user queries), and escalation to human agents (when AI cannot handle complex cases). In LangGraph, HITL is implemented using interrupt functions that pause execution, save state via checkpoints, and send messages to the frontend for human approval, with command functions resuming execution based on user decisions.

Agents are stateful software abstractions on top of stateless LLMs, enabling memory, message history, and persistence. State management is bidirectional: agents read state on the frontend while users send updates back. This enables collaborative experiences where agents render documents and users edit them in real-time. Front-end tools can execute actions with full DOM access while maintaining agent awareness. Human-in-the-loop interactions require agents to seek permission before executing certain actions, with the agent grounding itself in that state. This pattern scales to complex workflows like canvas applications where users can interact with agents through natural language while the agent maintains and updates application state.

Traditional automation platforms focus on linear workflows, but AI agents enable fuzzy decision-making and agentic automation that wasn't possible before. The chat UI is a major barrier to adoption because it's easier to interact with agents through text than through technical settings. For enterprise automation, design clear human-in-the-loop experiences where agents can escalate to humans when unsure, and humans can easily give instructions. After tasks are completed, agents should learn from interactions to improve. For fully autonomous agents, focus on analytics and monitoring systems rather than chat interfaces, including autonomous task labeling and reporting capabilities.