Stan Neo

As someone deeply invested in agentic systems and reinforcement learning, I find the Chain-of-Agents (CoA) approach both refreshing and practical, it takes the chaos of multi-agent orchestration and distills it into something elegant: a single model with native agent-like behavior. Here’s what I see: Traditional multi-agent setups have been great for modularity and reasoning, but they come with a high tax, too much inter-agent communication, redundant memory syncing, and unnecessary tool calls. What CoA proposes is radical in its simplicity: distill the behaviors of successful multi-agent runs into one model, then train that model to act as a team, internally. They start with multi-agent distillation: successful traces from existing orchestrators like OAgents are transformed into CoA-style traces, complete with planning steps, tool usage, reflections, and execution paths. But they don’t stop at replay, they filter hard cases and focus on high-quality trajectories that demonstrate useful agent behaviors like tool efficiency and coherent planning. This becomes the foundation of their SFT phase. Once that base is established, Agentic RL kicks in. The model is tasked with solving complex reasoning problems and importantly, ones where tools make or break the outcome (web QA, coding, math). Rewarding is done via exact-match or LLM-as-Judge strategies, making it possible to scale reward signals across noisy tasks. This setup tunes the model to reason reflectively, use tools judiciously, and respond with stability under diverse challenges. The kicker: by collapsing the roles of multiple agents into a single coherent model, CoA delivers an 84.6% reduction in inference cost. It’s a major unlock for production-grade agent systems where latency, memory, and tool limits matter. What excites me most is how CoA generalizes the spirit of ReAct/TIR, but upgrades it, dynamically invoking roles, using tools only when needed, and preserving a unified memory state that avoids the “who’s speaking now?” confusion. To me, Chain-of-Agents is a promising new frontier: a single-model, multi-mind architecture that captures the power of coordination while optimizing for real-world deployment constraints. And that’s where agentic AI needs to go. https://lnkd.in/exTxvsDD

63

2 Comments

[AI Paper] SFT is brittle because it ignores the model's "Internal Belief." We finally have a loss function that fixes this. 📉 As AI Architects, we accept "Catastrophic Forgetting" as the tax we pay for Domain Adaptation. We know that PPO/RLHF preserves general capabilities better than SFT, but the compute cost (Reference Models + Rollouts) is often prohibitive for standard fine-tuning jobs. A new paper, "Entropy-Adaptive Fine-Tuning" (EAFT), bridges this gap by identifying the root cause of SFT instability: Confident Conflicts. The Architectural Insight: Standard SFT treats all tokens equally. If the model predicts token A (confidently) but the ground truth is token B, SFT generates massive gradients to force the shift. The paper proves this is destructive. High Entropy (Uncertainty): The model doesn't know. SFT is safe here (learning new info). Low Entropy (Confidence): The model is sure. Forcing a change here breaks the pre-trained weights. The Solution (EAFT): They propose a dynamic, token-level gating mechanism based on entropy. Instead of a flat Cross-Entropy Loss, EAFT down-weights the loss when the model is in a state of "Confident Conflict." It effectively filters out the gradients that cause forgetting, mimicking the stability of On-Policy RL without the complexity. Why this belongs in your stack: Memory Efficiency: It has the exact same memory footprint as SFT (No Reward/Ref Models). Throughput: No rollouts required. Performance: It significantly outperforms NEFTune and vanilla SFT on knowledge retention benchmarks. If you are building custom fine-tuning pipelines, this is a drop-in replacement for your loss function. 👇 Link to the paper and code in the comments. #AIArchitecture #FineTuning #SFT #CatastrophicForgetting #LLM #MLOps #DeepLearning #EAFT

13

1 Comment

[AI Paper] We are finally treating Memory as an "Action Space," not just a "Storage Bucket." 🧠 As AI Architects, we usually treat Long-Term Memory (LTM) and Short-Term Memory (STM) as separate engineering problems. We use Vector DBs for LTM and Context Window sliding for STM. The agent has no real control over what it remembers; it's just passive retrieval. A new paper from Alibaba Group & Wuhan University, "Agentic Memory (AgeMem)," proposes a unified framework that changes this paradigm. The Architectural Shift: Memory as a Tool: Instead of a hidden background process, memory operations (Store, Retrieve, Update, Forget) are exposed as Tool Calls in the agent's action space. The model decides when to write to its own disk. Unified Policy: They don't use a separate "Memory Controller" model. They train the main agent (via a 3-stage RL process) to manage its own context, balancing LTM and STM dynamically. Progressive RL: The training recipe is key. It starts with "Memory-Free" warmups, moves to "Passive Memory" (learning to read), and ends with "Active Memory" (learning to write/manage). The Result: It outperforms standard RAG and heuristically managed memory systems (like MemGPT) on long-horizon tasks (HotpotQA) because the agent learns what is worth remembering. If you are building autonomous agents that need to run for days or weeks, "Passive Memory" isn't enough. You need "Active Memory Management." 👇 Link to the paper in the comments. #AIArchitecture #AgenticAI #MemorySystems #ReinforcementLearning #LLM #Alibaba #Research #AgeMem

18

1 Comment

If you currently use (or have used) our R package Tplyr, I have a draft of tplyr2 now available on GitHub. I'd love to get some real world testing of how it performs and what people think of the changes versus the original Tplyr.    The goal tplyr2 is to try to fix some of the core design decisions of Tplyr that became problems when we were in far too deep to fix them. As a high level summary: - It's a lot faster. A common complaint of Tplyr was that it's slow. I've recently been working on optimizations that about doubled the speed. I did some benchmarking, and the median speed up of Nested Count Layers (generally the slowest part of Tplyr) was another 3x. Part of this is a fresh rewrite of the code base. But otherwise, the backend is written with data.table to take advantage of the speed - No more NSE. It feels great when you're writing the code, but it was unwieldy to manage in the internals - In tplyr2 you make a spec, and then you build the spec - and you provide the data at build time. This is actually how rtables manages it, and I always appreciated that, because Tplyr's tables and layers had to carry the data. This meant a table wasn't really reusable, and it created convoluted work arounds like layer templates.  - Now that specs don't contain data, and with NSE gone, this allows you to save and load specs as JSON files.  - Tplyr had numeric data, which predated ARDs from CDISC. tplyr2 can write out ARDs, and also format a table given an ARD and a spec.  - The new group_analyze() function let's you define an analysis function, and build your own custom layer type. You can find the package website here: https://lnkd.in/etht7_S5 If you find issues during testing, you can drop issues here: https://lnkd.in/eDeXVn45 #rstats #statisticalprogramming #rprogramming #clinicaltrials #pharmaverse

73

8 Comments

https://lnkd.in/gYhCv7Wq Here is an interesting article which talks about the current status on were AI is heading. Majorly 1. All companies are re looking how they want to proceed with their AI strategy 2. Reliability will be a key metric when they look to deploy new AI solutions And finally like of earlier AI solutions, companies that can prove their AI actually works—demonstrably, consistently—will win What do you think? Is this article correct or is it more pessimistic on AI? #AI #ArtificialIntelligence #Innovation #Leadership #TechTrends #FutureOfWork

16

📄 My research paper “KinderAI Buddy: An Agentic, Multimodal AI Companion – A Research Framework for Safe and Personalized Child Learning” has been published as a preprint on SSRN. 🤖 I tried to explore how AI can become a safe, personalized, and engaging learning companion for children — built on the principles of agentic intelligence, multimodal interaction, and safety by design with guardrails. 💡 This research is also personally meaningful to me, inspired by my own experiences as a parent and the need for trustworthy, child-centred AI in early education. 🌍 Thrilled to share this milestone on how we can shape responsible AI for the next generation. 👉 Link to the paper: https://lnkd.in/gYF5PFkz #AI #Education #ChildLearning #Research #SSRN #AgenticAI #

113

11 Comments

In collaborative machine learning (CML), early contributors take on more risk and encourage participation from wait-and-see parties, but existing CML frameworks treat every party as if they join simultaneously. The #NeurIPS2025 paper of Jiangwei Chen, Nguyen Pham, Rachael Sim, Arun Verma, Zhaoxuan Wu, Chuan Sheng Foo, and Bryan Kian Hsiang Low proposes a time-aware CML framework that rewards parties not just for what they contribute, but when they contribute: •⁠ ⁠8 incentives extending fairness with time-aware notions that incentivize early participation while preventing low-quality early submissions. •⁠ ⁠2 reward distribution methods that theoretically satisfy all incentives and recover the #ShapleyValue in time-agnostic cases. •⁠ ⁠A practical recipe for constructing valuation functions and reward realization, with empirical validation on synthetic and real-world data. Find our more at our posters! #NeurIPS2025 Thu, Dec 4, Exhibit Hall C, D, E #1104 #EurIPS2025 Wed, Dec 3, Poster Stand #56 Paper: https://lnkd.in/g_yM6j39 #FederatedLearning

50

Agent Memory - is it a critical bottleneck? A new survey from researchers across NUS, Renmin, Fudan, and other institutions offers the most comprehensive taxonomy of agent memory to date. The core insight: existing frameworks like "short-term vs. long-term memory" are insufficient. The field has become fragmented, with researchers using the same terms to describe fundamentally different systems. The authors propose a unified lens of "forms, functions, and dynamics." Memory forms include token-level (explicit, editable text), parametric (encoded in model weights), and latent (hidden states and KV caches). Functions are divided into factual memory (what the agent knows), experiential memory (how it improves), and working memory (what it's thinking about now). Dynamics covers how memories are formed, evolve, and retrieved over time. They identify the following convergence: reinforcement learning is increasingly taking over memory management, moving from hand-crafted rules toward fully learnable systems. The paper argues we may see agents that autonomously design their own memory architectures through RL optimization. All in all, this survey provides a conceptual foundation for building the next generation of agents that can genuinely learn and adapt over time. ↓ 𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

240

13 Comments

In 2019 Animit Kulkarni and myself joined MQube to solve document extraction with AI. It was a daunting time. We were fresh out of uni and our jobs depended on what was an open research problem. We were lucky that BERT came out the month we joined. It was the language model that made everything else possible later. We were in the office til 9pm debugging loss curves and hoping that at least tonight we won’t need to reinstall CUDA again. A few months later, v1 of our document extraction pipeline was launched. It was a success. Many versions later, document extraction is a solved problem for MQube. What is strange is that lenders treat document extraction as an open problem. We have met large lenders that have 30+ people manually reviewing payslips and AI models that never get deployed. AI progress faster than organisations can adopt it. This will keep happening. This is the real bottleneck.

40

2 Comments

🔴 Emergent Introspective Awareness in LLMs: this is the first rigorous evidence that large language models possess a limited but genuine ability to observe and report on their own internal processes — a capability that challenges longstanding assumptions about what these systems can do and raises profound questions about their future development. When researchers at Anthropic injected the concept of "betrayal" into their Claude AI model's neural networks and asked if it noticed anything unusual, the system paused before responding: "I'm experiencing something that feels like an intrusive thought about 'betrayal'." If models can accurately report their own reasoning, it could fundamentally change how humans interact with and oversee AI systems. https://lnkd.in/d2a9zS5j

47

2 Comments

to make a RAG system work well one has to tweak parameters 🎛️ Follow our AAAI  2026 paper (even better - meet Matan Orbach in Singapore this week) to learn how this could be done automatically and efficiently. Check out the Paper - Hyper-Parameter Optimization for RAG: https://lnkd.in/dFr-MNeD

8

Excited to share a recent paper: “Out-of-Context Abduction: LLMs Make Inferences About Procedural Data Leveraging Declarative Facts in Earlier Training Data” by Imran et al. This work investigates whether large language models can infer the most plausible explanations for observations by retrieving relevant facts from their pre-training corpus—what the authors term out-of-context abduction. Key Contributions: • Defining Out-of-Context Abduction: Unlike in-context abduction, which relies on hypotheses presented alongside observations, this form tests whether LLMs can leverage declarative knowledge from earlier training to explain procedural examples. • Experiment 1: GPT-4o, after being declaratively fine-tuned on chatbot personas, correctly inferred the “Pangolin” persona (responds only in German) with an 84% posterior probability—significantly above its 49% prior—simply by observing German-language responses. • Experiment 2: Through iterative fine-tuning on responses with increasing proportions of vowel-starting words (the “Axolotl” persona), GPT-4o demonstrated accelerated trainability that aligns with abductive inference mechanisms. How They Achieved It: 1. Declarative Fine-Tuning: Hand-crafted Q&A pairs associating each persona’s name with abstract behavior descriptions were used to bias the model without exposing it to example dialogues. 2. In-Context Behavior Examples: Procedural demonstrations (e.g., German replies or vowel-word responses) were encoded separately from the declarative facts to prevent simple pattern matching. 3. Off-Policy Iterative Fine-Tuning: By binning generated responses according to characteristic scores and re-training on the highest-scoring subsets, the authors measured how prior knowledge boosts learning efficiency. Why It Matters: • Emergent Reasoning: Provides strong evidence that LLMs can perform multi-hop abductive reasoning—first hypothesizing a behavior description, then mapping it back to a class name—beyond mere surface pattern matching. • AI Safety & Alignment: Situational awareness via out-of-context abduction could enhance AI assistance but also poses risks like identity inference or evaluation gaming, underscoring the need for robust interpretability and monitoring. This research opens new avenues for exploring latent reasoning in LLMs and informs safer deployment strategies. #MachineLearning #LLM #AbductiveReasoning #AISafety #AIResearch #GenAI #AI

9

Fine-Tuning LLMs — The Smart Way Forward Fine-tuning large language models (LLMs) used to mean retraining billions of parameters, demanding insane compute and memory. For most teams, that’s simply not feasible. But we’ve come a long way. Today, we can fine-tune LLMs efficiently using parameter-efficient fine-tuning (PEFT) techniques. Here are five popular approaches redefining what’s possible: 🔹 LoRA: Train small low-rank matrices (A & B) instead of full weights. 🔹 LoRA-FA: Freeze matrix A to reduce memory needs, train only B. 🔹 VeRA: Use shared, random A & B across layers; learn small layer-specific scalars. 🔹 Delta-LoRA: Apply the difference between A·B matrices to the main weights W. 🔹 LoRA+: Boost learning rate selectively for B to optimize convergence. These approaches make it practical and scalable to specialize models for healthcare, legal, customer support, or even your internal business processes — without breaking the bank. Whether you’re building an internal AI assistant or a vertical-specific GenAI tool, PEFT is the future. Read more: https://lnkd.in/gt4J4j2Y #LLM #FineTuning #AI #MachineLearning #LangChain #GenAI #LoRA #PEFT #AIProducts #ParameterEfficientTuning #OpenSourceAI

10

2 Comments

While benchmark performance often guides large language model selection, production environments reveal a different reality. Reinforcement Learning from Human Feedback (RLHF) and preference-optimization methods impose behavioral constraints that define the architectural success boundaries of multi-agent systems. Preference-optimization aligns generalist conversational models (Gemini, Claude) toward helpful, fluent responses, optimizing for rapid engagement and concise, confident answers. These models excel at intent extraction and iterative exploration. However, in multi-file codebases, they exhibit premature solution convergence, emitting code before fully modeling the repository architecture. This yields structurally fragile changes unless the system enforces a strict read–analyze–plan–edit loop. Conversely, specialized reasoning models (o1-style reasoning families, DeepSeek-R1) show an inverse profile. They allocate substantial test-time compute to internal chain-of-thought and context assimilation before generating final tokens, often producing hundreds to thousands of reasoning tokens on harder tasks. This yields deeper architectural awareness and stronger structural coherence; however, the added latency and verbosity break rapid-prototyping loops when deployed naively as drop-in chat replacements. Production routing patterns: effective architectures route tasks by cognitive load, not benchmarks: ↳ Conversational models handle exploratory analysis and requirements extraction to leverage low latency and high interactivity. ↳ Synthesis/reasoning models execute state transformations across 10k+ LOC and complex refactoring, where high context fidelity and structural coherence dominate. ↳ Sequential routing with explicit handoff contracts governs hybrid workflows, strictly defining which agent plans, edits, and verifies. Failure boundaries: orchestration overhead exceeds gains when tasks are below ~500 LOC or require fewer than three meaningful context switches. In these cases, single-model invocation with an extended context window typically outperforms multi-agent routing by bypassing coordination, retries, and glue logic. Observability requirements: without instrumentation for per-model token usage and context-window saturation, engineers debug RLHF mismatches by feel. Observability must come before routing decisions; teams cannot tune cognitive profiles they do not measure. Commercial narratives emphasize general-purpose intelligence. In practice, engineering teams deploy specialized inference profiles within deterministic topologies—performance scales when the system architecture accommodates RLHF constraints rather than fighting them. #SystemsArchitecture #SoftwareEngineering #MLOps #EnterpriseAI #AgenticAI #LLMEngineering

🍿 Hugging Face transformers used to support multiple backends. However, given the user base has consolidated in PyTorch, they recently made an announcement that going forward, the transformers library will only support PyTorch as its sole backend and thus reduce a lot of the bloating contributed by the abstraction layers present for supporting multiple backends. This will make the library leaner and easier to contribute to. Support for TensorFlow and JAX will be dropped in v5 of transformers. However, support for all three backends will continue in v4 under LTS (until ~2026). #pytorch #transformers #python #LLMs

4

I just stumbled upon this from Ministry of Statistics and Programme Implementation (#MoSPI), and it’s honestly inspiring: 👉 https://lnkd.in/gcXXKQBF This is not just data access - it’s forward-looking public infrastructure. By opening up official statistics in such an explorable, machine-friendly way, the ministry is effectively inviting citizens, researchers, and builders to think with the data. Within a minute of playing with it, a beautiful insight emerged: 📊 States with higher literacy often report higher unemployment. Counter-intuitive, until the data reveals why: Educated youth search longer for suitable jobs Informal work absorbs the less-educated, masking job stress rather than solving it This unemployment–literacy paradox is exactly the kind of insight that becomes visible only when data is open, well-structured, and easy to explore. Kudos to MoSPI for the creativity and foresight to unlock a true statistical treasure trove for Bharat. This is how evidence-driven understanding and better policy conversations begin. Sometimes, progress starts quietly … with democratising one well-designed dataset 🇮🇳📊 #ai #democratisation #bharat IndiaAI

149

3 Comments

🚨 Reaching out to my network for some practical guidance — an ask for rigor. As I’ve been digging deeper into LLMs and AI agents, I keep running into a recurring theme: a surprising lack of precision and structure, even from experienced engineers. There’s often hand-wavy advice where hard thinking should be. So here’s a challenge I’m working through: 🧠 Context Imagine a team or division full of tribal knowledge — insights from subject matter experts (SMEs) across domains. This could range from how certain quant models behave to which SQL tables work well together. You want to capture this knowledge and make it accessible via LLM-powered Q&A — reliably, accurately, and scalably. 🎯 The Goal Build a knowledge base that avoids hallucinations and ensures trustworthy answers. The stakes are high: this system should be something people can count on. ❓The Ask If you've tackled something similar, how did you structure your knowledge base? What formats or workflows actually worked to avoid false answers? Structured docs? Embedded metadata? Something else? We already know that plain RAG + embeddings will only take you so far… But before you answer, I want to bring some serious stakes into the mix — advice I got from Ronald Hua when we shipped our first alpha model at GSAM. These two questions from him have shaped how I approach things ever since: 1. Would you bet your own money on your model? 2. Do you know when to turn it off? Whatever solution you suggest here — imagine you can answer a confident YES to both for your approach on how to create standardized templates or formats for SMEs to articulate their knowledge Let’s bring the rigor back. 💬👇

33

8 Comments