Sanjay Vishwakarma(He/Him)

Claude just released a memory import tool: https://lnkd.in/eM8c7Gf5 You paste a prompt into ChatGPT (or whatever you're using), it spits out your context — preferences, projects, how you work — and you drop it into Claude's settings. That's it. Claude picks it up from there. The switching cost has always been the real barrier. Not the AI itself, just the fact that you've spent months building context somewhere else. This is Anthropic admitting that out loud and actually doing something about it. Quiet release. Worth knowing about.

2

𝗔𝗿𝗲 𝗠𝗼𝗱𝗲𝗹 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗳𝗿𝗼𝗺 𝗔𝗣𝗜𝘀? You may think APIs were enough for AI agents, Then when you looked into 𝗠𝗼𝗱𝗲𝗹 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗣𝗿𝗼𝘁𝗼𝗰𝗼𝗹 (𝗠𝗖𝗣), you realize APIs are powerful, but they weren’t built for how LLMs operate. • 𝘼𝙋𝙄𝙨 𝙖𝙧𝙚 𝙜𝙚𝙣𝙚𝙧𝙖𝙡-𝙥𝙪𝙧𝙥𝙤𝙨𝙚 great for structured system interactions, but they rely on pre-defined endpoints, and agents need custom adapters to use them. • 𝙈𝘾𝙋 𝙞𝙨 𝙥𝙪𝙧𝙥𝙤𝙨𝙚-𝙗𝙪𝙞𝙡𝙩 AI agents can ask what tools or data are available at runtime, and everything is exposed in a consistent, machine-readable format. One interface, Multiple services, No redeploys. Many MCP servers are just wrapping traditional APIs - but with a layer that actually speaks agent. Over the past few months, a range of protocols have emerged to standardize how AI agents communicate, collaborate, and function. As systems grow more autonomous, having defined protocols is no longer optional — it's essential. This 10 of the most prominent AI agent protocols shaping the future of intelligent systems: ➤ ACP (IBM) – Defines standard interfaces for agent interaction and lifecycle management. ➤ AGP (Industry) – Enables message transformation and access control between agents and external systems. ➤ A2A (Google) – Powers structured communication in multi-agent environments like Gemini and Project Astra. ➤ MCP (Anthropic) – A unified model context protocol for memory injection and tool usage in LLMs. ➤ TAP (LangChain) – A standardized JSON schema for tool abstraction and execution. ➤ OAP (Community) – An open protocol for framework interoperability across agent runtimes. ➤ RDF-Agent (Semantic Web) – Leverages SPARQL and linked data for semantic agent communication. ➤ AgentOS (Proprietary) – Provides a runtime stack for long-lived, enterprise-grade agents. ➤ TDF (Stanford) – Task schema for modular prompt planning and goal coordination. ➤ FCP (OpenAI) – A standardized way to invoke LLM functions with schema enforcement. Each protocol addresses a unique layer in the agentic AI stack — from communication to memory, task coordination to function invocation. 𝗜𝘁’𝘀 𝗻𝗼𝘁 𝗔𝗣𝗜𝘀 𝘃𝘀 𝗠𝗖𝗣 - 𝗶𝘁’𝘀 𝗮𝗯𝗼𝘂𝘁 𝗺𝗮𝗸𝗶𝗻𝗴 𝗔𝗣𝗜𝘀 𝘂𝘀𝗮𝗯𝗹𝗲 𝗮𝘁 𝗔𝗜 𝘀𝗰𝗮𝗹𝗲. #LLM #MCP #APIs #AIagents

3

Get faster and smarter MOE inference straight out of the box. 👇Deep dive on scaling expert parallelism with TensorRT-LLM. LLMs with MOE promise higher model capacity without linearly increasing compute costs - but they introduce new challenges -- more conditional computation, dynamic routing, and non-uniform GPU utilization -- solved by TensorRT-LLM. ✨ New in TensorRT-LLM has native support for expert parallelism—designed for fast, efficient inference with MoE models like Mixtral (Mistral AI) and DeepSeek (DeepSeek AI). This gives you: ✅ Dynamic expert routing: Automatically route tokens to the top-k experts with minimal overhead. ✅ Efficient expert scheduling: Balance expert loads across GPUs using smart sharding and token bucketization. ✅ Memory-aware execution: Maximize hardware utilization while respecting memory budgets. ✅ Drop-in support: Use @HuggingFace models with minimal code changes via TensorRT-LLM's #Python API. 🧠 How it works: MoE models activate only a subset of "experts" for each token. This dynamic nature is powerful—but hard to optimize. It’s all done under the hood using custom #CUDA kernels and NCCL-based communication primitives—giving you low latency, high throughput, and better GPU scaling. ✨ TensorRT-LLM handles: ✅Token-expert mapping using the gating network. ✅Token sorting to batch same-expert tokens together. ✅Expert parallel execution across GPUs. ✅Merging outputs for final predictions. 🛠️ Developer workflow - here is the code to get started. # Clone the repo git clone https://lnkd.in/g-GiDX23 # Use included examples to load and run a Mixtral model cd TensorRT-LLM/examples/mixtral From there, the Python API lets you load the model, convert it with TensorRT, and run expert parallel inference—all with a few lines of code. Results? 📈 Performance at scale. Tests show up to 2.3x faster inference throughput compared to standard tensor parallelism when using 8 GPUs and top-2 experts per token. Even better—TensorRT-LLM keeps efficiency high across increasing batch sizes. Want to see it in action or contribute? 👉 Read the full tech blog: https://lnkd.in/g_7YV3vV 👉 Explore the code on GitHub: https://lnkd.in/gNjQ5W2U 👉 Follow updates in the TensorRT-LLM repo: https://lnkd.in/gqSHYQ4u Share your experiences with us.

78

3 Comments

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

In physical autonomy, evaluating a plan based on its semantic plausibility guarantees failure. The architectural requirement is proving that an action is safe under bounded uncertainty. Language models generate plans through token prediction, a probabilistic process optimized for semantic coherence rather than physical safety. When those plans activate motors and servos, failure modes shift from hallucinated text to physical collision, drift, and hardware damage. The mismatch is structural: token prediction cannot validate the real-time state space. Autonomous systems fail due to accumulated sensor error, dynamic overshoot, and latency-driven desynchronization. A model that proposes "move the gripper 15cm left" cannot verify whether that instruction violates joint limits, exceeds payload capacity, or intersects an obstacle that appeared moments earlier. Scaling model parameters improves pattern recognition, not constraint enforcement. Safe autonomous architecture pairs probabilistic cognition with deterministic execution controls. Four boundaries enforce that separation: ↳ State reconciliation gate: The control system continuously reconciles intended motion with measured reality using proprioception, vision, and Inertial Measurement Unit (IMU) telemetry at control-rate frequencies (10–1000 Hz+, depending on the embodiment). If the measured state diverges beyond tolerance, the system halts or replans. ↳ Deterministic feasibility gate: A validation engine gates every proposed motion through deterministic checks before execution—forward kinematics for reachability, inverse dynamics for torque limits, and collision checks (e.g., swept-volume constraints). If any constraint fails, the gate rejects the motion unconditionally. ↳ Independent safety interlocks: Firmware-level circuit breakers and emergency-stop logic override model outputs when sensors detect force spikes, proximity violations, or thermal limits. These mechanisms operate independently of the probabilistic stack; a crashed inference server cannot disable them. ↳ Platform decoupling: The autonomy stack must treat physical embodiment as a swappable dependency. Architectures that bind the reasoning layer directly to proprietary hardware interfaces create structural fragility. When vendors deprecate interfaces, tightly coupled stacks break. Hardware abstraction layers are load-bearing constraints, not optimization targets. This separation builds on established engineering foundations. Traditional motion planning and control already rely on deterministic methods such as RRT* and Model Predictive Control (MPC) to enforce feasibility. Generative models add valuable intent synthesis, inferring semantic goals from ambiguous instructions, but the final arbiter of safe execution must remain verifiable. Architects must treat the large language model as an untrusted planner, requiring deterministic evidence before committing any actuator. #SystemsArchitecture #EnterpriseAI #AIGovernance

5

2 Comments

🧠 Model Context Protocol (MCP): The Future of Structured AI Interactions In the fast-evolving world of Generative AI, building truly intelligent systems means more than just prompting a large language model — it requires structured, contextual reasoning. That’s where Model Context Protocol (MCP) comes in. In my latest Medium article, I break down: 🔹 What MCP is and why it’s critical for building multi-agent and tool-augmented LLM systems 🔹 How context is passed between agents, memory, retrievers, and tools 🔹 Real-world use cases like: - AI Telemedicine Assistants - RAG-powered Enterprise Bots - Financial Portfolio Advisors 🔹 With working Python examples to help you implement it yourself This article is written for AI engineers, builders, and anyone exploring advanced GenAI workflows. Would love to hear your thoughts or any feedback from others building in this space 🚀 #GenerativeAI #AI #LLM #LangChain #OpenAI #OCI #MCP #AgenticAI #PromptEngineering #RAG

10

2 Comments

👀 ⭐️ #Bookmark Paper: "KV Cache Steering for Inducing Reasoning in Small Language Models" Cache steering improves reasoning in language models through a single intervention in the key-value cache, enhancing both reasoning structure and task performance. 📄 Paper: https://lnkd.in/gxPvW6Mg 💻 Code: https://lnkd.in/gdVcBcKb #LLMs #cache #kvcache #reasoning #SLMs

11

Time for DLM - Data Language Model !! Existing LLMs ( Large Language Models) are trained on sentences / text and they predict next word or sentence. LLM components ( Embedding, Multi-head attention, Encoder-Decoder transformers, SoftMax,), and eco-systems ( RAG, Embedding models) are optimized for documents / sentences. For data intensive products , we will need DLM (Data Language Model) which will help with data discovery, data prediction , data quality, data summarization, etc. There are some LTM s( Large Table Models) which are inspired by for LLMs but I think their focus is, on how to train the model to optimized the storage for faster output. That solve only one part of the problem. We also need SLM ( Small language models) which understands the data professionals use-cases and call the right agents , embedding model. A hybrid model !! I think future embedding models will be bespoken built for specific use-cases , i,e embedding model for search, embedding model for prediction etc. Again data products , unlike LLMs output are deterministic. A DLM should not give different outputs , in different runs :) Feel free to share your thoughts.

11