IntelliJ IDEA’s Post

Excited to see the Agent Client Protocol ecosystem keep growing! The ACP Java SDK brings Java developers a simpler way to build agents that work across IDEs.

Great to see this evolution in the agent ecosystem. Standardization layers like ACP can do for AI agents what LSP did for languages—unlock true interoperability across IDEs. For Java developers, this is a strong step toward building context-aware, portable agents without being tied to a single toolchain. Looking forward to how this shapes developer productivity and workflows going forward. #Java #AI #Agents #DeveloperTools #Innovation #SoftwareEngineering

I’ve had my eye on ACP, but for lack of a Java SDK, it wasn’t high on my list of things to look into. Mark seems to have changed that by creating a Java SDK for ACP. I’ll definitely have a look at this.

I’m excited to share the announcement of the next major release of the Tascalate Async/Await library. This library extends Java to support the async/await programming paradigm across Java versions 8 through 25, delivering a seamless, developer-friendly approach. By offering runtime APIs and bytecode enhancement tools, it enables Java developers to use async/await programming style with syntax closely similar to what's found in C# 5+ or modern ECMAScript. This allows to use imperative programming constructs like for/while loops, if/switch statements, structured exception handling etc, while preserving all the benefits of asynchronous programming without blocking threads. The Tascalate Async/Await provides support for asynchronous tasks and asynchronous generators within any kind of Java application. In this new release, it provides robust integration with SpringBoot projects, supporting Standalone, WebServlet/SpringMVC and WebFlux setups. Additionally, it offers two-way integration with Reactor.io stream publishers, with plans to add the similar functionality for SmallRye Mutiny in an upcoming release. The library is entirely free from gluten, lactose, albumin, Generative AI-generated code, formaldehyde, paraphenylenediamine, and any other allergenic components. For more details and detailed documentation, visit the project’s homepage at: https://lnkd.in/d9dEyjDd.

Coding agents are innovating fast, but they're also getting bloated. To actually understand what they’re doing, you have to go back to the basics. A good way to learn is to get into it. Adding LSP support to the 260 line nanocode agent in #Java https://lnkd.in/ec5j8QpJ

Been thinking about Java migration for a while now. Not the kind of thinking where you make a Confluence doc and call it a day. The kind where you actually build the thing. So I built anneal. And I'll be honest — this was my first real project with Quarkus and LangChain4j. Twenty years of Java, Spring Boot, ATG, enterprise everything. And here I am learning new frameworks while building something I actually care about. That part felt good. anneal points at a Java 8, 11, or 17 codebase, walks the AST, matches 22 migration rules across every LTS boundary, scores the risk per hop — not one big scary number, a score per crossing so you know exactly where the danger is — and then runs each finding through a local LLM to explain what needs to happen and why. No cloud required. Runs on your machine. Code stays where it belongs. The stack — - Quarkus 3.33.1 on Java 25. Kubernetes-native, fast, CDI done right. Coming from Spring Boot this was a genuine pleasure. - LangChain4j 1.13.0 wired to Ollama locally. codellama:13b for code reasoning, llama3.1:8b for prose. claude-sonnet-4-6 as opt-in cloud fallback for the complex refactors. - Deterministic AST detection via JavaParser. The rule engine either finds `import sun.misc.Unsafe` or it doesn't. No hallucinations in the detection layer. LLM only enriches the explanation. - pgvector storing 384-dim MiniLM embeddings per finding. Pure Java ONNX — no Python, no sidecar, no network call. - Pure Java. One deployable unit on the JVM. Scanned a legacy Java 8 codebase this week. Seven findings. Risk score 66 — HIGH. JPMS violations, removed APIs, deprecated patterns, modernization opportunities. All explained. All grounded in the actual source. First Quarkus project. First LangChain4j project. Probably not the last. alright — it's out in the open. https://lnkd.in/gwuzY_hA Feedback welcome. Especially from anyone who's survived a Java 8 → 17 migration in production. Or anyone else picking up Quarkus for the first time. #java #quarkus #langchain4j #llm #softwaredevelopment #ai #java25 #opensource

🚀 Built an LLM Observability Tool for Java — without changing a single line of application code. Over the past few days, I worked on a project called TraceLM — a lightweight observability system for LLM-based Java applications. 👉 The idea was simple: How do you understand what your LLM is doing in production? Most applications today: Don’t track latency properly Don’t know which model is used Have zero visibility into token usage Make debugging extremely hard So I built a solution 👇 🔍 TraceLM (Java Agent-based Observability) It uses a Java Agent (ByteBuddy) to intercept LLM calls and capture: ✅ Latency (avg, p95) ✅ Model usage (auto-detected) ✅ Request count ✅ Token estimation ✅ Error tracking 👉 And the best part: ⚡ Zero code changes required in your application 🧠 How it works Application → Java Agent → Collector → Metrics API The agent intercepts LLM calls at runtime Sends trace data to a collector (Quarkus) Exposes metrics via REST API 📊 Example metrics: Total requests Average latency Error rate Token usage Requests per model 💡 This is just the beginning. Next steps: Dashboard UI 📊 Persistent storage Token-level accuracy Alerts & anomaly detection 🔗 GitHub: https://lnkd.in/g2S8pRsB Would love feedback from the community — especially from folks working with LLMs in production 🙌 #Java #LLM #Observability #AI #OpenSource #LangChain #Quarkus #ByteBuddy #SoftwareEngineering

Most developers use Java every day… But very few truly understand what happens inside the JVM. 🤯 Let’s simplify JVM internals in 60 seconds 👇 When you run a Java program, it doesn’t directly execute your code. It goes through multiple layers inside the JVM: 👉 1. Class Loader Subsystem - Loads ".class" files into memory - Ensures classes are loaded only once - Follows delegation model (Bootstrap → Extension → Application) 👉 2. Runtime Data Areas (Memory) This is where things get interesting: - Heap → Stores objects (shared across threads) - Stack → Stores method calls & local variables (thread-specific) - Metaspace → Stores class metadata (replaced PermGen) - PC Register → Tracks current execution - Native Method Stack → For native (C/C++) calls 👉 3. Execution Engine - Interpreter → Executes bytecode line by line - JIT Compiler → Converts hot code into native machine code for speed 🔥 Why JIT matters? Frequently used methods get optimized → huge performance boost 👉 4. Garbage Collector (GC) - Automatically cleans unused objects - Prevents memory leaks - Works mainly in Heap (Young Gen / Old Gen) 💡 Real-world insight: Most production issues are NOT due to business logic… They are due to: - Memory leaks - GC pauses - Improper heap sizing 🚀 Pro Tip: If you understand JVM internals, you can debug issues faster than 90% of developers. What JVM concept do you find most confusing? Let’s discuss

Learn how to build enterprise agentic apps in Java with this insightful article from Red Hat Developers. Stay ahead of the curve with our expert tips and best practices!