Sandeep Uttamchandani, Ph.D.

To add to that, Confluent Cloud Network (CCN) routing simplifies private networking for Flink, reusing existing Kafka infrastructure. It helps teams quickly connect secure pipelines across cloud environments. Security is further strengthened with IP Filtering—giving teams greater control over access in hybrid environments and enabling them to confidently deploy AI at scale. With these enhancements, Confluent is not just enabling smarter AI—it’s making it enterprise-ready. Organizations can now unlock: Seamless integration of historical and streaming data Secure, scalable infrastructure for AI agents Faster, context-aware decisions powered by trusted data Agentic AI is here. With Confluent Cloud, it’s ready for the enterprise. https://lnkd.in/gh-dA7qs #ConfluentCloud #ApacheFlink #SnapshotQueries #AgenticAI #RealTimeData #StreamProcessing #DataAnalytics #EnterpriseAI #BatchProcessing #DataStreaming #DigitalTransformation #Flink #AI #MachineLearning #DataSecurity #PrivateNetworking #IPFiltering Follow our LinkedIn page for more such interesting CX expert opinions/ Thought Leader Interviews/ CX Leadership news/ articles/ updates https://lnkd.in/g9eeFFgh

1

Still confused between MCP, A2A, and Functional Calling? These three approaches are reshaping how LLMs and agents operate at scale, but each one solves a very different problem. Let’s break it down 👇 1. Model-Context Protocol (MCP) MCP manages dynamic context windows across enterprise LLM infrastructure. It retrieves prior memory, history, and metadata to personalize every response without hardcoding logic into prompts. 2. Agent-to-Agent Protocol (A2A) In A2A, agents talk to each other directly using shared protocols. Think of it as collaborative problem-solving between specialized local agents, especially useful in multi-agent ecosystems. 3. Functional Calling Here, an LLM acts like a planner. It decomposes a task (e.g., comparing market caps), generates a Directed Acyclic Graph (DAG) of subtasks, and then sends each task to appropriate tools (math, search, APIs) for execution. Conclusion - MCP is about managing context, - A2A is about agent collaboration, - Functional Calling is about task execution. Mastering all three is key to building powerful, production-ready AI systems. Save this visual for your next AI project!

357

52 Comments

Custom silicon efforts like Maia (detailed below). As a point of comparison, Microsoft has commented on successfully diversifying its CPU share with its Cobalt ARM-based CPU, which debuted in 2023 and was implemented in production workloads in 2024. Liftr Insights third party observability tooling suggests that Cobalt was behind 33% of new Azure VMs in 4Q24. More customers are choosing AMD as a second source provider. Our Semis team models AMD's GPU share expanding from 5% in 2025 to 8% in 2028. In our meeting with Scott Guthrie, EVP of Cloud and AI, at Microsoft Ignite in November 2025, Microsoft noted it is already diversifying its GPU supplier base and expects this to have a favorable impact on pricing into 2026.

1

‘Responsible AI is about private deployments with strong guardrails, governance, and domain-specific controls. Focus is on trust, explainability, and compliance.’ ——— Great post from Swathi Young. Highly recommend following if not already.

16

1 Comment

YellowDog.ai just set a 10x benchmark uplift in scale computing, delivering 40,000 tasks per second (TPS) and managing 100,000 compute nodes in the cloud. What's even more interesting, that's 2x IBM Symphony and opens an intriguing pathway for these until-know closed/captive systems.

11

Andrew Ng reported from Davos, that AI deployment for transformative impact will require workflow redesign. It is "theory of constraints" all over again (remember Eli Goldratt's "The Goal"?), we have to understand that real business benefits come only from working across silos, from analyzing flow bottlenecks, from understanding that optimizing non-bottlenecks creates waste. As Ng noted, letting a thousand (AI) flowers bloom has failed to lead to significant payoffs. Obviously! We in the silicon industry are no strangers to this. Workflows have been stagnant for decades. Technologies for high level specification, high level synthesis, and formal verification are not yet integrated into the full silicon development flow. They are often done piece-meal, and enthusiasts' pilots are dropped at the hint of a failure or delay. People say they want formal verification in their flow, but want it yesterday and do not have the time to invest in training engineers for its rigorous usage. Ashish Darbari, responding to a question on "if formal verification is so powerful then how come it is not widely used", noted that the problem is in the name - the actual task to be done is formal analysis while the bug detection is only a corollary, but the industry puts the cart before the horse. Based on my experience with industrial practice of high level specifications and formal verification, I tend to agree with his succinct comment. Jan Rabaey, in a DAC keynote speech, said that someday he expects to see a comic book series entitled "adventures in formal verification". AI deployment faces the same problem, if not actively worked on by business leaders. To be fair, deployments of all disruptive technologies face this mental barrier, we are so used to thinking in terms of the old flow (using the old technology) that thinking of a new flow literally means us having to begin again from first principles - few leaders have the courage and the time to do that. Goldratt mentioned that he himself had faced the same mindset problem when deploying the early ERP solutions and was surprised why he wasn't getting the expected large benefits, and he said it took him many years before he could identify the core problem and define solutions for it, which he named (rather academically) as "theory of constraints". AI leaders would do well to rework the conventional workflows in a holistic manner in order to get the real benefits from this new technology. As Henry Ford had said, "If you always do what you've always done, you'll always get what you've always got".

21

💡 LLMs have trouble with nested sequence of API calls with parameters that depend on response from previous calls. Can MCP help? For example, when the LLM generates a sequenece of API calls to sort out a problem: "What is the difference between the squares of 4 and 3?" Calls needed to solve this: {"name": "square", "arguments": {arg_0: 4}, "label": "$var_1"} {"name": "square", "arguments": {arg_0: 3}, "label": "$var_2"} {"name": "subtraction", "arguments": {arg_0: var1.resultvar1​.result, arg_1: var2.resultvar2​.result}, "label": "var_3"} The best performing models can get through these tests successfully only 25% of the time! Crazy! Connecting these APIs to the LLM via MCP by itself doesn't directly solve this problem, but it can help. You can think of the MCP server as a smart, stateful orchestrator of the backend API calls, and can do things like store the results between different tool calls and let the LLM refer to the results by variable name (resolving the actual values behind the scenes). This is an example of a stateful MCP server, and the spec supports this. I thought this was a great paper I stumbled upon from a post by Paul Lundin "NESTFUL: A Benchmark for Evaluating LLMs on Nested Sequences of API Calls" https://lnkd.in/d369aXgR

22

1 Comment

Today let's talk about Parallel Fan Out/ Concurrent Agentic Design pattern and when parallel agents go rouge What’s the Concurrent Orchestration Pattern? Imagine a scenario where multiple AI agents—each with its own lens or specialty—tackle the same task simultaneously. Instead of a single, step-by-step chain, tasks fan out to different agents in parallel. Then their outputs are merged or aggregated for the final answer. It’s the AI equivalent of a brainstorming session where everyone chips in together. This pattern thrives when you need diverse insights or speed—think ensemble reasoning or reaching a verdict faster. This pattern is commonly used in agentic RAG. Here’s how you can apply it in a Retrieval-Augmented Generation (RAG) system: Step 1: Break the user’s query into smaller sub-queries (e.g., “Define concept X,” “List use cases,” “Give examples”) and map out their dependencies. Step 2: Run those sub-queries in parallel—agents fetch context or process each in isolation (e.g., document retrieval, summarization, external tool usage). Step 3: Once all agents have results, aggregate the findings into a single, coherent response. This technique lets you parallelize independent parts, reducing latency while maintaining clarity—especially effective when sub-queries don’t depend on each other. Super Important : Try to avoid this pattern and use sequential execution even if it's slow, but it might yield a good result, below is the reason As Cognition [the company behind devin] warns in a famous blog post “Don’t Build Multi-Agents”, things can go sideways fast if agents don’t share context or coordination is weak. When agents operate in isolation—making decisions based solely on their own view—the final result might be fragmented, contradictory, or just plain incoherent. Think two agents building different puzzle pieces that don’t fit. The core issues: Context fragmentation: Each agent works in a silo, leading to mismatched assumptions. Implicit decisions: Agents’ outputs reflect unspoken choices that may clash when merged. Coordination complexity: Without strong orchestration, integration becomes error-prone. References : 1. Concurrent Execution Pattern : https://lnkd.in/gZybgm2s 2. LLM Compiler whitepaper : https://lnkd.in/gWwGJhbi 3. Coginition blog Don't build multi agents which shows parallel execution can yield agent drift : https://lnkd.in/gkDKC4TP

14

3 Comments