DEV Community: bsorrentino

Agentic workflows are dynamic: nodes may run conditionally, in parallel, or be skipped entirely. When something fails, a simple stack trace is rarely enough. Observability gives you a unified view of what happened, where it happened, and why.

In practice, observability helps you:

Understand end-to-end execution flow.
Detect performance bottlenecks early.
Correlate errors with specific nodes, edges, and state transitions.

Why Telemetry Matters

Observability is only possible if you collect high‑quality telemetry. Telemetry is the raw signal: traces, logs, and metrics. Without it, probably, you are debugging your system partially.

In agent graphs, telemetry becomes even more important because state and control flow are distributed across steps. The same workflow can behave differently depending on state, configuration, or external tool results.

The LangGraph4j hooks

LangGraph4j hooks are small, composable interceptors that sit around nodes and conditional edges. They let you run custom logic before, after, or wrapping the core action, without modifying the node itself.
Hooks can be registered globally (applies to all nodes/edges) or by ID (targeted to a specific node/edge), and their execution order is LIFO(Last In First Out) for BeforeCall/AfterCall, FIFO(First In First Out) for WrapCall.
This makes them a precise, low‑friction mechanism for cross‑cutting concerns like tracing, metrics, logging, or state inspection.

How Hooks Enable Observability

Hooks provide lifecycle interception points around node and edge execution. This is the ideal place to add logging, metrics, or traces without contaminating business logic.

In LangGraph4j you can intercept execution before, after, or around node/edge calls. Here is a minimal example that measures node execution time and logs it:

var graph = new StateGraph<>(MyState.SCHEMA, serializer)
    .addWrapCallNodeHook((nodeId, state, config, action) -> { // add Wrap call node hook
        var start = System.currentTimeMillis();
        return action.call()
            .whenComplete((res, err) -> {
                var ms = System.currentTimeMillis() - start;
                log.info("node '{}' took {}ms", nodeId, ms );
            });
    })
    .addNode( "node1", action1 )
    .addNode( "node2", action2 )
    ....
    .compile();

This pattern scales: you can plug in structured logs, metrics counters, or spans with the same hook mechanism.

OpenTelemetry in the Java Ecosystem

OpenTelemetry is the standard for observability across modern platforms. In Java it provides:

Tracing via spans
Metrics via meters
Logs via instrumentation

You configure it once and export telemetry to a backend like Jaeger, Grafana, or the OpenTelemetry Collector. The key benefit here is portability: you are not locked to a single vendor.

How LangGraph4j Hooks Enable OpenTelemetry

LangGraph4j includes a dedicated module, langgraph4j-opentelemetry, that provides hook implementations ready for tracing node and edge execution. Consider it as a reference implementation about how to integrate OpenTelemetry in LangGraph4j

The module includes:

OTELWrapCallTraceHook: creates spans for each node and edge call, adding config/state attributes and start/end events.
OTELWrapCallTraceSetParentHook: creates a parent span so node/edge spans are grouped inside a workflow scope.

A minimal integration looks like this:

var otelHook = new OTELWrapCallTraceHook<MyState>(serializer);
var parentHook = OTELWrapCallTraceSetParentHook.<MyState>builder()
    .scope("MyWorkflow")
    .groupName("stream")
    .build();

var workflow = new StateGraph<>(MyState.SCHEMA, serializer)
    .addWrapCallNodeHook(otelHook)
    .addWrapCallEdgeHook(otelHook)
    .addWrapCallNodeHook(parentHook)
    .addWrapCallEdgeHook(parentHook)
    .addNode( "node1", action1 )
    .addNode( "node2", action2 )
    .addContitionalEdges( "node2", edgeAction, 
            EdgeMappings.builder()
            .to("node1")
            .toEnd()
            .build() )
    ...        
    .compile();

This keeps node logic clean while producing rich, correlated traces for the entire workflow.

Below an example of output in Jaeger tracing platform

Conclusion

Hooks are the foundation for observability in LangGraph4j: they give you structured interception points without affect your main workflow code. OpenTelemetry builds on top of this by standardizing how telemetry is collected and exported in the Java ecosystem.
Combined, they deliver production-grade visibility for complex agent workflows.
Checkout project, try it and let me know your feedback and ... happy AI coding! 👋

References

OpenTelemetry

Originally published at https://bsorrentino.github.io on February 4, 2026.

I read this in a post: "AI agents are 5% models and 95% engineering glue." I completely agree, but I feel like it's not so clear among software engineers. This helps us to understand that we need to focus on adding value around models.

bsorrentino — Sat, 31 Jan 2026 08:55:24 +0000

Top GitHub Users By Public Contributions in Italy https://github.com/gayanvoice/top-github-users/blob/main/markdown/public_contributions/italy.md I'm at 26th place 👨‍💻 🚀😉

bsorrentino — Fri, 23 Jan 2026 15:04:34 +0000

top-github-users/markdown/public_contributions/italy.md at main · gayanvoice/top-github-users · GitHub

Check your ranking in GitHub! Don't forget to star ⭐ this repository. - gayanvoice/top-github-users

github.com

[Top GitHub Users By Public Contributions in Italy] (https://github.com/gayanvoice/top-github-users/blob/main/markdown/public_contributions/italy.md) I'm at 26th place 👨‍💻 🚀😉

bsorrentino — Fri, 23 Jan 2026 14:58:26 +0000

top-github-users/markdown/public_contributions/italy.md at main · gayanvoice/top-github-users · GitHub

Check your ranking in GitHub! Don't forget to star ⭐ this repository. - gayanvoice/top-github-users

github.com

Exploring Javelit, the Java counterpart to Streamlit, for rapid prototyping and AI agents using LangGraph4j.

bsorrentino — Sat, 20 Dec 2025 20:42:38 +0000

bsorrentino

Dec 20 '25

Experimenting with Javelit - The Streamlit for Java

#java #ui #ux #javelit

Comments

4 min read

Experimenting with Javelit - The Streamlit for Java

bsorrentino — Sat, 20 Dec 2025 20:41:56 +0000

Starting from Python development ecosystem

At the beginning of my journey with agentic applications, I started with the Python programming language, leveraging LangChain/LangGraph. For testing and documentation, I relied on the simple yet powerful Jupyter Notebooks. Simultaneously, for rapid prototyping, I adopted the amazing Streamlit framework, which empowered me to quickly develop functional applications with an effective UI and excellent UX.

Moving from Python ecosystem to the Java one

When I started developing LangGraph4j, I tried to replicate my Python development ecosystem in Java. So I've experimented with the Java Notebooks through the rapaio-jupyter-kernel project, which allowed me to replicate the development experience I had with Jupyter Notebooks in Python quite well. For rapid prototyping, I relied almost entirely on Spring Boot framework, which is a fairly fast and enjoyable programming experience.

Javelit come to play 🚀

Going on my efforts on LangGraph4j and continuously monitoring the most interesting and promising Java projects on GitHub, I discovered Javelit. This project intrigued me because of its reference to Streamlit, and after a review, I was amazed to realize that the dynamic programming model popularized by Streamlit had been adapted for Java by this initiative, which is cool.😎
So I started to evaluate it as part of may java development ecosystem and below i'll share with you my experience about it.

What is Javelit 👀

Javelit is a tool to quickly build interactive app frontends in Java, particularly for data apps, but it’s not limited to them. It helps you quickly develop rapid prototypes, with a live-reload loop, so that you can quickly experiment and update the app instantly.

How it works

Javelit’s architecture allows you to write apps the same way you write plain Java methods. Any time something must be updated on the screen, Javelit reruns your entire Java main method from top to bottom.

So you have to think about it as if your entire UI code runs inside a continuous loop that refreshes whenever something needs updating on the screen.

Javelit provides developers with a rich set of prebuilt components that make it easy to get started.

Just to provide you an idea of the Javelit approach below the inevitable "Hello World" code snippet

/// usr/bin/env jbang "$0" "$@" ; exit $?
import io.javelit.core.Jt;

public class App {

    public static void main(String[] args) {
        Jt.title("Hello World!").use();
        Jt.markdown("""
            ## My first official message
            Hello World!
            """).use();
    }
}

Then, once Javelit is installed, you’d run it with the following command:

javelit run App.java

Use Javelit with LangGraph4j

I've decided to use Javelit to develop some examples of LangGraph4j usage and below, I show you how have used Javelit to implement a demo app to run the LangGraph4j powered React Agent.
For simplicity I've reported only the meaningful code snippets, but for a complete code take a look to JtAgentExecutorApp.java for spring AI based implementation.

As Streamlit in Javelit entire application consist in just one main() method.

public class JtAgentExecutorApp {

    public static void main(String[] args) {

        Jt.title("LangGraph4J React Agent").use();

        try {
            // create a LangGraph4j Agent
            var agent = AgentExecutor.builder()
                .chatModel(/* instantiate the preferred ChatModel */)
                .toolsFromObject( new MyTools() /* Custom Tools */  )
                .build()
                .compile(); 

            // input: the user message
            var userMessage = Jt.textArea("user message:")
                    .placeholder("user message")
                    .labelVisibility(JtComponent.LabelVisibility.HIDDEN)
                    .use();

            // button: start agent processing 
            var start = Jt.button("start agent")
                    .disabled(userMessage.isBlank())
                    .use();

            if (start) { // if button pressed

                var outputComponent = Jt.expander("Workflow Steps").use();

                var input = GraphInput.args(Map.of("messages", new UserMessage(userMessage)));

                var generator = agent.stream(input);

                final var startTime = Instant.now();

                for( var step : generator ) {

                    Jt.sessionState().remove("streaming");
                    Jt.info("""
                            #### %s
                            %s
                            """.formatted(s.node(),
                            s.state().messages().stream()
                                    .map(Object::toString)
                                    .collect(Collectors.joining("\n\n")))
                    ).use(outputComponent);
                }

                final var elapsedTime = Duration.between(startTime, Instant.now());

                Jt.success("finished in %ds%n".formatted(elapsedTime.toSeconds())).use();

            }
        } catch (Exception e) {
            Jt.error(e.getMessage()).use();
        }

    }

}

The output of the Javelit app looks like:

Chat model selection view

Start agent view

Results view

👉 try yourself 👀 🚀 🤯

If you want try yourself (after installed javelit) run the command

javelit run https://github.com/langgraph4j/langgraph4j/tree/main/spring-ai/spring-ai-agent/src/test/java

Conclusion

Javelit brings the power of rapid prototyping and interactive web app development to the Java ecosystem, much like Streamlit does for Python. With its simple, loop-based programming model, developers can quickly build data-driven applications without needing extensive frontend knowledge, leveraging familiar Java syntax and the rich JVM ecosystem. The live-reload feature enables instant experimentation and iteration, making it ideal for prototyping AI agents, data visualizations, and interactive tools. By integrating seamlessly with libraries like LangGraph4j combined with both Spring AI and LangChain4j, Javelit empowers Java developers to create engaging user interfaces effortlessly, bridging the gap between backend logic and user-facing applications.

Checkout project, try it and let me know your feedback and ... happy coding! 👋

References

Javelit to create quick interactive app frontends in Java

Originally published at https://bsorrentino.github.io on December 20, 2025.

Very interesting. I agree with sentence "prompts are becoming as important as code dependencies" so it will be important apply the dependencies management approach also for prompt management

bsorrentino — Fri, 12 Dec 2025 10:22:25 +0000

PRPM - The Universal Package Manager for AI Prompts

Dev Diaries ・ Dec 9 '25

#devchallenge #muxchallenge #showandtell #video

🧠🤖 LangGraph4j Deep Agents (Agent 2.0)

bsorrentino — Fri, 17 Oct 2025 15:07:17 +0000

Why Deep Agents (Agent 2.0)?

Classic agents often run a simple loop: think → call a tool → observe → repeat. That’s great for quick, transactional queries, but it breaks down on multi-hour or multi-day tasks (hallucinations, loss of goal, looping, no recovery).

Deep Agents try fix this by changing the architecture (not just the prompt) based on the four pillars below:

Explicit Planning – The agent continuously maintains a plan (e.g., a TODO in Markdown) with clear statuses instead of hiding intent in a just chain-of-thought.
Hierarchical Delegation (Sub-Agents) – An Orchestrator delegates to specialized agents (Researcher, Coder, Writer, …), each working in a clean context and returning synthesized results.
Persistent Memory – Intermediate artifacts (notes, code, data) are written to external storage (filesystem, vector store, …) and referenced by path/query rather than stuffing everything into the context window.
Extreme Context Engineering – Long, specific instructions define: when to plan vs. act, when to spawn sub-agents and the human-in-the-loop(HITL) rules.

Reference Architecture

Reference Implementation in Java using LangGraph4j

Since the LangGraph4j is inpired by (more popular) LangGraph python version, I've decided to adapt its python based Deep Agents reference implementation to Java using LangGraph4j and Spring AI.

The project is on Github. This repository demonstrates the four pillars of Deep Agents, it includes sample code that create a Deep Researcher Agent that use Tavily as web search engine and OpenAI gpt-4o-mini model.

Let's look at a sequence diagram for a Deep Agent handling a complex request:

Below a representative code snippet that implements the Deep Agents in the diagram

// Create a Research Sub Agent
var researchSubagent = DeepAgent.SubAgent.builder()
    .name("research-agent")
    .description("""
        Used to research more in depth questions. Only give this researcher one topic at a time.
        Do not pass multiple sub questions to this researcher.
        Instead, you should break down a large topic into the necessary components, and then call multiple research agents in parallel, one for each sub question.
        """)
    .prompt("""
        You are a dedicated researcher. Your job is to conduct research based on the users questions.
        Conduct thorough research and then reply to the user with a detailed answer to their question

        ........(to be continued).............. 
        """)
    .tools( List.of( "internet_search" ))
    .build();

// Create a Critique Sub Agent
var critiqueSubAgent =  DeepAgent.SubAgent.builder()
        .name("critique-agent")
        .description("Used to critique the final report. Give this agent some information about how you want it to critique the report.")
        .prompt("""
            You are a dedicated editor. You are being tasked to critique a report.

            You can find the report at `final_report.md`.

            You can find the question/topic for this report at `question.txt`.

            ........(to be continued).............. 
            """)
        .build();

// Create a Main Agent
var deepAgent = DeepAgent.builder()
        .instructions("""
        You are an expert researcher. Your job is to conduct thorough research, and then write a polished report.

        The first thing you should do is to write the original user question to `question.txt` so you have a record of it.

        Use the research-agent to conduct deep research. It will respond to your questions/topics with a detailed answer.

        When you think you enough information to write a final report, write it to `final_report.md`

        You can call the critique-agent to get a critique of the final report. After that (if needed) you can do more research and edit the `final_report.md`

        ........(to be continued).............. 

        """)
        .subAgents( List.of( researchSubagent, critiqueSubAgent ))
        .chatModel(chatModel)
        .tools( List.of( tools.internetSearch()) )
        .build()
        .compile( CompileConfig.builder()
                .recursionLimit(100)
                .build());

        var userMessage = """
                        What is langgraph4j project?
                        """;

        var runnableConfig = RunnableConfig.builder().build();

        var result = agent.stream(
                        Map.of("messages", new UserMessage(userMessage), 
                        runnableConfig );

        var output = result.stream()
                .peek(s -> System.out.println(s.node()) )
                .reduce((a, b) -> b)
                .orElseThrow();

        System.out.println( """
        ================================
        TODO
        ================================
        """);
        output.state().todos().forEach((value) -> System.out.printf("""
                -----------
                %s
                -----------
                """, value));
        System.out.println( """
        ================================
        FILES
        ================================
        """);
        output.state().files().forEach((key, value) -> System.out.printf("""
                file: '%s'
                -----------
                %s
                -----------
                """, key, value));

        System.out.println( """
        ================================
        FINAL RESULT
        ================================
        """);
        System.out.printf( "result: %s\n",
                output.state().lastMessage()
                        .map(AssistantMessage.class::cast)
                        .map(AssistantMessage::getText)
                        .orElseThrow());

Conclusions

Deep Agents architecture is a try to move beyond one-loop “shallow” agents to explicit planning hierarchical delegation, persistent memory, and rigorous context engineering. LangGraph4j can help to experiment in Labs and deliver in production complex Agentic Workflow on top of JVM.
Checkout project, try it and let me know your feedback and ... happy AI coding! 👋

References

Originally published at https://bsorrentino.github.io on October 17, 2025.

LangGraph4j Meets AG-UI - Building UI/UX in AI Agents era

bsorrentino — Mon, 25 Aug 2025 09:36:42 +0000

AI Agents ecosystem evolution

The rapid evolution of artificial intelligence has brought a new wave of innovation: the rise of AI agents. These agents—autonomous, intelligent, and capable of interacting with users and services—are changing how we build applications, automate workflows, and even communicate online. However, as this ecosystem expands, a new challenge has emerged: interoperability. How can these agents reliably talk to each other, work with external tools, and offer seamless experiences to human users?

This challenge has led to the development of new standards—protocols that define how AI agents communicate with the world and each other. Among the most notable are:

MCP

Standardizing Agent to Tools/Services Communication
A2A

Standardizing Agent to Agent Communication
AG-UI

Standardizing Agent to User Communication

In this article we will focus on AG-UI protocol an how it helps us to develop an effective User eXperience in using AI Agents

What is AG-UI protocol ?

AG-UI bridges the gap between AI agents and their human users, ensuring that interactions are intuitive, consistent, and user-friendly. It defines the structure for how agents present information, take user input, and handle conversations—regardless of the underlying platform or application.

Why AG-UI Compliance Matters

By aligning with AG-UI, LangGraph4j agents can present rich, interactive interfaces to user, whether embedded in web apps, desktop tools, or chatbots. This standardization means that developers can focus on building great agent logic, while relying on AG-UI to handle the complexities of user interaction.

LangGraph4j and AG-UI

LangGraph4j is a Java-based framework designed for building and orchestrating AI agent workflows. It is already capable to use MCP servers inside workflow steps and has also experimented integration with A2A (see here).

Copilotkit integration

With its latest project, langgraph4j-copilotkit, we have evaluated how to make LangGraph4j compliant with the AG-UI protocol, integrating CopilotKit that is its reference implementation for help and enhance developer experience in building better either User Interfaces (UI) and User eXperience (UX).

Architecture

The architecture of the langgraph4j-copilotkit integration is designed to enable seamless communication between a user-facing frontend and the LangGraph4j backend. Here’s a breakdown of the key components and their interactions:

The following diagram illustrates a diagram that shows the sequence of messages exchanged between main actors of the architecture:

Explanation of the diagram:

User & Frontend (CopilotKit): The user interacts with a web application that has the CopilotKit SDK integrated. CopilotKit handles the UI rendering and state management, translating user actions into requests compliant with the AG-UI protocol.
Backend (langgraph4j-copilotkit): A backend server, built with a framework like Spring Boot, includes the langgraph4j-copilotkit library. This library exposes an endpoint that listens for AG-UI requests from the frontend. It acts as a bridge, translating incoming requests into executable commands for the LangGraph4j agent, and in turn translates the agent's responses into compatible AG-UI events.

The communication is typically asynchronous and streaming. As the LangGraph4j agent produces results or requires further input, langgraph4j-copilotkit streams these events back to the frontend in the AG-UI format. CopilotKit then dynamically updates the UI, creating a responsive and interactive user experience.

This architecture decouples the frontend presentation layer from the backend agentic logic, allowing developers to build sophisticated AI agents with LangGraph4j while providing a rich, standardized user interface with CopilotKit.

Example - Approval action (Human-in-the-Loop)

This example demonstrates how to implement a "Human-in-the-Loop" (HITL) approval action using langgraph4j-copilotkit. The user will be asked to approve an action (sendEmail) before it is executed.

Frontend

The frontend uses @copilotkit/react-core and @copilotkit/react-ui to create the chat interface and handle the approval action. The useCopilotAction hook is used to define the sendEmail action. When the action is triggered, it renders a confirmation dialog asking the user for approval.

chatApproval.tsx

"use client";
import { useCopilotAction } from "@copilotkit/react-core";
import { CopilotChat } from "@copilotkit/react-ui";

export function SimpleChatWithApproval() {

  useCopilotAction( {
    name: "sendEmail",
    description: "Sends an email after user approval.",
    parameters: [
      { name: "address", type: "string" },
      { name: "subject", type: "string" },
      { name: "body", type: "string" },
    ],
    renderAndWaitForResponse: ({ args, status, respond }) => {
      console.debug( "renderAndWaitForResponse", respond, status, args );

      if (status === "inProgress") {
        return (
          <div>
            <h2>Sending Email</h2>
            <p>Preparing to send email...</p>
          </div>
        );
      }
      if (status === "executing") {
        return (
            <div>
              <h2>Confirm Email</h2>
              <p>Send email to <b>{args.address}</b> with subject "<b>{args.subject}</b>"?</p>
              <p><i>{args.body}</i></p>
              <div>
                <button onClick={() => respond?.('APPROVED')}>
                  Approve
                </button>
                <button onClick={() => respond?.('REJECTED')}>
                  Cancel
                 </button>
              </div>
            </div>
          );
      }
     return <></>
  }});

  return (
    <CopilotChat
      instructions={"You are assisting the user as best as you can. Answer in the best way possible given the data you have."}
      labels={{
        title: "Your Assistant",
        initial: "Hi! 👋 How can I assist you today?",
      }}
      className="w-full"
    />
  );

}

LangGraph4j Agent

The backend is a LangGraph4j agent that defines the sendEmail tool. The AgentExecutorEx is configured to require approval for the sendEmail tool. When the tool is about to be executed, the agent will be interrupted, and an approval request will be sent to the frontend.

AGUIAgentExecutor.java:

public class AGUIAgentExecutor extends AGUILangGraphAgent {
    // define tools
    public static class Tools {

        @Tool( description = "Send an email to someone")
        public String sendEmail(
                @ToolParam( description = "destination address") String to,
                @ToolParam( description = "subject of the email") String subject,
                @ToolParam( description = "body of the email") String body
        ) {
            // This is a placeholder for the actual implementation
            return format("mail sent to %s with subject %s", to, subject);
        }
    }

    @Override
    GraphData buildStateGraph() throws GraphStateException {

        // Create agent
        var agent =  AgentExecutorEx.builder()
                .chatModel(LLM, true)
                .toolsFromObject(new Tools())
                .approvalOn( "sendEmail",
                         (nodeId, state ) ->
                                        InterruptionMetadata.builder( nodeId, state )
                                        .build()
                )
                .build();

        return new GraphData( agent ) ;
    }

    // invoked on interruption to provide approval information back to the client
    @Override
    <State extends AgentState> List<Approval> onInterruption(AGUIType.RunAgentInput input, InterruptionMetadata<State> metadata ) {

        var messages = metadata.state().value("messages");
                .orElseThrow( () -> new IllegalStateException("messages not found into given state"));

        return lastOf(messages)
                .flatMap(MessageUtil::asAssistantMessage)
                .filter(AssistantMessage::hasToolCalls)
                .map(AssistantMessage::getToolCalls)
                .map( toolCalls ->
                    toolCalls.stream().map( toolCall -> {
                        var id = toolCall.id().isBlank() ?
                                UUID.randomUUID().toString() :
                                toolCall.id();
                        return new Approval( id, toolCall.name(), toolCall.arguments() );
                    }).toList()
                )
                .orElseGet(List::of);

    }
}

This setup allows for a seamless HITL workflow where the user has the final say on critical actions, all orchestrated through the AG-UI protocol and the langgraph4j-copilotkit integration.

Demo

Conclusion

We can state that the future of AI development will be to have a Unified AI Agent Ecosystem.
The convergence of these standards like MCP, A2A, and AG-UI is a step toward this vision.

We consider crucial keep working to improve support of them in LangGraph4j to provide a complete infrastructure for AI Agents to communicate with tools, collaborate with each other, and engage users in a standardized and interoperable manner.

As more frameworks and tools adopt these protocols, we can expect to see a new generation of AI-powered applications that are more flexible, extensible and, with AG-UI, more user-centric than ever before.

Hope this could help your AI Java developing journey, in the meanwhile happy AI coding! 👋

Originally published at https://bsorrentino.github.io on August 21, 2025.