Did you know that AI (ChatGPT eg) hallucinates (- makes up fabricated facts) sometimes up to 50 % of the time? Great share Dries Faems, for all people in my network here is the Hallucination Minimizer. Very helpful as the hallucination rates of ChatGPT and other AI tools are still high, 40 % in some cases. When you use AI agents this percentage will become higher. Check before you act, have your compliance in place! Be safe network!

Is RAG really Dead? Not exactly but naive long-context RAG is hitting its limits. LLMs aren’t bad at reasoning. They’re bad at reading very long inputs. Most long-context failures are reading failures, not reasoning failures: • Attention dilution • Context rot • Missed or mixed information Recursive Language Models (RLMs) change the paradigm: • Treat data as an external environment • Inspect, decompose, and reason recursively • Avoid stuffing everything into one prompt Key shift From “read everything” → “navigate and reason” What this enables: • Reasoning over millions of tokens • Better performance on information-dense tasks • Reduced context degradation • Lower or comparable inference cost Bottom line: RAG isn’t dead it’s evolving toward agentic, recursive, and navigation-based reasoning. Open question: Will recursive reasoning become the default for long-context AI, or will it remain a specialized technique? Share your perspective in the comments. #RecursiveLanguageModels #GenerativeAI #LLMs #AIResearch #InferenceScaling #FutureOfAI

The Prompt Paradox: Why More Context is Making AI Lie 🧩 We’re told "Context is King." But in the math of Large Language Models, too much context is actually a hallucination trigger. It’s counter-intuitive. In the physical world, more data equals more certainty. In a Transformer model, it’s the opposite. The Math of Failure • Entropy vs. Signal: Every extra word you add increases the entropy (disorder) of the input. Since Attention is a finite mathematical resource, your "goal" gets diluted by "noise." The model eventually has to guess which part of your prompt is actually the priority. • The "U-Shaped" Curve: Models suffer from a "Lost in the Middle" effect. They are excellent at the beginning (primacy) and end (recency) of a prompt, but accuracy collapses in the center. If your key instruction is buried, the AI fills the gap with statistical nonsense. • Logical Friction: Every constraint is a new variable. Too many variables create "glitches" where the AI fabricates a reality just to satisfy your conflicting rules.

𝐑𝐀𝐆 vs. 𝐆𝐫𝐚𝐩𝐡𝐑𝐀𝐆 🔍 – How to make AI more intelligent Retrieval-Augmented Generation (RAG) is a proven method to enhance the answers of large language models (LLMs) with real-world information. By using similarity search, RAG quickly finds relevant information, already delivering very good results. GraphRAG takes it a step further: it links knowledge from different sources into a knowledge graph, creating logical, deeper connections. This makes the AI not just better informed but also “smarter” by enabling it to answer complex questions through networking and logical reasoning. GraphRAG thus introduces a whole new quality in AI assistance – moving away from simple search towards genuine understanding of complex topics. Have you already extended your RAG?

The Rise of RLM over LLM 🚀 We often think that making AI “bigger” (giving it more memory or context) will make it smarter. But that is not always true. When today’s AI models get too much information at one time, they become confused and start making mistakes. This problem is called “context rot.” Now a new idea is coming: Recursive Language Models (RLMs). They solve this problem in a smarter way. ⸻———— 🔹 LLM (Large Language Model) How they work: Like a person trying to read one very big book in one sitting and answer from memory. Problem: • Forget important details in long documents • Struggle with complex, multi-step problems ⸻ 🔹 RLM (Recursive Language Model) How they work: Like a professional researcher. They break a big task into small parts, take notes, use tools, and ask smaller AIs to help. Benefit: • Do not get overwhelmed • Can handle very large data • Solve problems step-by-step with better accuracy ⸻ ✨ In short: LLMs try to remember everything. RLMs learn how to think, plan, and solve problems intelligently. The future of AI is not about bigger memory — It is about smarter problem-solving. #GenerativeAI #LLM #RLM #ArtificialIntelligence #FutureOfWork #Technology

🚀 Context Length Is No Longer the Bottleneck MIT CSAIL just dropped a powerful idea: Recursive Language Models (RLMs). Instead of forcing massive prompts into an LLM (and watching performance collapse), RLMs treat the input as external data. The model searches, filters, chunks, and recursively calls itself using code. 📌 Why this matters: - Handles 10M+ tokens - Beats long-context LLMs, summarization & retrieval agents - Scales with problem complexity, not context window - Comparable or lower inference cost 💡 Big shift: Stop scaling context length. Start scaling reasoning structure at inference time. This feels like a major step toward long-horizon reasoning systems and agentic AI that can truly scale. Link : https://lnkd.in/ghRB8qDQ #AI #LLMs #MachineLearning #Agents #InferenceScaling #Research\

🔬 I compressed 92% of an LLM's memory. Quality loss? Zero. The backstory: Curious how ChatGPT handles 100K+ tokens, I dove into research papers. One word kept appearing: "cache." Found this on entropy-based information management: https://lnkd.in/e3HGKHci Just finished research on entropy—clicked instantly. What if it could guide LLM cache compression? What I tested: 4 compression methods on GPT-2. Kept only 8% of cache. Real tasks: QA, code gen, language modeling. Findings: 92% memory savings, zero quality loss StreamingLLM: 21% faster (keeps first + last tokens) Entropy-guided: 18% faster + 11% better on reasoning Key difference: Adaptive vs. fixed positioning The insight: Simple wins on speed for short contexts. But 50-page contracts or 10K-line code where info is buried in the middle? Adaptive selection dominates. 📊 Benchmark: https://lnkd.in/eErJSzYb 📝 Deep-dive: https://lnkd.in/eyzH5Ukz What applications need long-context AI? 👇 #MachineLearning #AI #LLM #Research #DeepLearning

I realized something critical about how Large Language Models actually work. We tend to treat AI like a logic machine. A + B = C. So we give it strict instructions: "Do this, then this, using exactly this word." But LLMs are not logic machines. They are Probability Engines. They have digested billions of data points to understand what "good" looks like. They have a mathematical "intuition" for how concepts connect. The moment you micro-manage the prompt, you break that intuition. You're choking the model. When you force the AI to follow 10 specific steps, you force it into a narrow corner of its data. You are overriding its training with your rules. You are effectively telling the super-intelligence: "Don't use your brain, use mine." And that is why the output feels average. The advanced move is to stop defining the Path and start defining the Destination. I stopped telling the AI how to write or create. Instead, I tell it the Vibe. I tell it the Outcome. "Make this feel urgent." "Make this feel sophisticated." This gives the model "Latent Space Freedom." It allows the AI to scan its entire database to find the best mathematical path to achieve that feeling. Guardrails? Yes. You need to tell it where to go. Handcuffs? No. Don't tell it how to drive. If you want average results, give instructions. If you want magic, give direction. #AI #MachineLearning

⚡ Agent-As-A-Judge For the last few years, we have built AI systems that were evaluated by LLMs (LLM-as-Judge), where you’d take a massive model like GPT-5, feed it a response from the smaller model, and ask, “Is this good?” It worked mostly because it was faster and cheaper than hiring a fleet of humans to read every word. But there are challenges with LLM-as-a-Judge: 1. Incredible Bias: If you give a standard LLM two answers, it will almost always pick the longer one, regardless of whether it’s actually better. 2. Hallucinated Correctness: A static LLM judge is a passive observer. It looks at a piece of code and thinks, “Yeah, that looks like code.” It doesn’t actually run the code to see if it crashes the computer. In specialized fields like medicine or law, “looking right” isn’t enough; you need the answer to actually be right. 3. Cognitive Overload: If you ask a single LLM to evaluate a response based on grammar, factual accuracy, tone, and safety all at once, it gets overwhelmed. The result? A global score that misses all the interesting nuances. The key difference introduced by the Agentic Judge is the ability to shift the thinking from “Passive Reader” to “Active Investigator”. Categorize these systems into three stages of “agency”: 1. Procedural Agents: These follow a strict, predefined script. They might break a task into parts, but they don’t deviate from the plan. 2. Reactive Agents: These are a bit smarter. They can change their path based on what they find. If a search result is confusing, they might decide to dig deeper or ask a different question. 3. Self-Evolving Agents: This is the current “final boss” of AI evaluation. These systems can actually refine their own grading rubrics on the fly based on the complexity of the task. Read here for details: https://lnkd.in/g8NXruTS

⚡ Agent-As-A-Judge For the last few years, we have built AI systems that were evaluated by LLMs (LLM-as-Judge), where you’d take a massive model like GPT-5, feed it a response from the smaller model, and ask, “Is this good?” It worked mostly because it was faster and cheaper than hiring a fleet of humans to read every word. But there are challenges with LLM-as-a-Judge: 1. Incredible Bias: If you give a standard LLM two answers, it will almost always pick the longer one, regardless of whether it’s actually better. 2. Hallucinated Correctness: A static LLM judge is a passive observer. It looks at a piece of code and thinks, “Yeah, that looks like code.” It doesn’t actually run the code to see if it crashes the computer. In specialized fields like medicine or law, “looking right” isn’t enough; you need the answer to actually be right. 3. Cognitive Overload: If you ask a single LLM to evaluate a response based on grammar, factual accuracy, tone, and safety all at once, it gets overwhelmed. The result? A global score that misses all the interesting nuances. The key difference introduced by the Agentic Judge is the ability to shift the thinking from “Passive Reader” to “Active Investigator”. Categorize these systems into three stages of “agency”: 1. Procedural Agents: These follow a strict, predefined script. They might break a task into parts, but they don’t deviate from the plan. 2. Reactive Agents: These are a bit smarter. They can change their path based on what they find. If a search result is confusing, they might decide to dig deeper or ask a different question. 3. Self-Evolving Agents: This is the current “final boss” of AI evaluation. These systems can actually refine their own grading rubrics on the fly based on the complexity of the task. Read here for details: https://lnkd.in/grUEHwg8