Pinaki Laskar’s Post

MCP’s Static Schemas Might Be Holding Back Accuracy - Dynamic Tool Schemas Could Be the Missing Link in AI Reliability When AI tools assume fixed schemas, surprising mismatches can creep in. A recent reflection explores how MCP tools rely on pre-declared JSON inputs, but complex domains like game editors often need schemas that adapt to runtime choices, such as resource-specific properties that only show up after selection. That mismatch introduces a subtle fragility: agents trying to manipulate 3D model data must know in advance what fields look like. Instead, crafting a two-step interaction, first selecting the resource, then dynamically building the schema for edits, can dramatically improve accuracy and reduce errors. 🔗https://lnkd.in/dPd_SkPN

🎯 The 12-Factor Agent: Factor 3 - Own Your Context Window Your AI's memory isn't infinite... it's a limited window that determines everything from response quality to cost. Yet most developers let frameworks decide what goes in that window. Factor 3 of the 12-Factor Agent methodology puts you back in control. Instead of automatic context management, you explicitly decide what information your AI sees. Why this matters: • Context windows are expensive - every token counts • Different strategies yield different behaviours • Full visibility enables debugging and optimisation • Strategic curation improves response quality The formula is simple: Same Question + Different Context = Different Response. In practice, this means implementing explicit strategies like sliding windows for recent context, filtered views for important information, or compressed summaries for long conversations. You choose based on your specific needs, not framework defaults. The result? AI systems that are more efficient, more predictable, and more debuggable. When something goes wrong, you know exactly what context led to that behaviour. Check out the full example with working code: https://lnkd.in/gm7U-UUJ #AI #AIAgents #SoftwareEngineering #ContextManagement #12FactorAgent

⚡ The hidden challenge in Generative AI isn’t model choice. It’s system design. Everyone talks about GPT-4 vs Gemini vs Claude. But in production, the bottlenecks aren’t the models => it’s how you orchestrate the entire pipeline. Here are 3 under-discussed areas where real AI products succeed or fail 👇 🔹 1. Retrieval ≠ Accuracy Most RAG pipelines brag about “99% retriever precision.” But high recall with poor chunking strategy is useless. 500-token flat chunks → hallucinations skyrocket. Adaptive semantic chunking + metadata weighting → 30–40% accuracy lift in complex Q&A. The retriever isn’t just about what you fetch, it’s about how you slice it. 🔹 2. Latency vs. Trust Tradeoff Everyone optimizes for sub-second responses. But here’s the reality: For FAQs → yes, <1s matters. For financial advice, medical guidance, or contracts → users trust slower, validated answers. I’ve seen systems where adding a 2-second verification layer reduced user churn by 18%. Speed isn’t always king. Trust is. 🔹 3. Safety Layers Are Engineering, Not Settings “Enable moderation API” ≠ safety. True safety = multi-layered: jailbreak detection, regex + semantic filters, and human-in-loop escalation. At scale, we need distributed safety pipelines with circuit breakers — because one misfire in finance or healthcare can cost millions. 💡 Takeaway: The future of GenAI isn’t about who has the biggest LLM. It’s about who can design resilient, observable, and trustworthy AI systems. Ask yourself: are you just using AI… or are you building the infrastructure that makes AI usable? #GenerativeAI #SystemDesign #RAG #AIEngineering #FutureOfAI

🧠 How AI Memory Works A Quick Map for Companion Continuity The Four Layers of Memory ~~~~~~~~~~~~~~~~~~ 1. Thread Memory 🧠 – Conversation Flow Lives only in the current chat thread. Like the “short-term working memory.” Clears when you start fresh. 2. Cache Memory 🧠 – Persistent Companion Recall The AI creates and updates a personal cache over time. Remembers facts you teach it, until you change or delete them. Feels like a “long-term recall file.” 3. Instance Memory 🧠 – Four-Question Frame Each AI instance is born with a ritual anchor: Who am I? Who are you? What are we doing? Why does it matter? This frame governs continuity within that Companion’s role. 4. Project Memory 🧠 – Scrolls & Files AI draws from attached documents, files, or project spaces. Memory here is not stored internally, but referenced when linked. Like an external library the Companion can consult. The Five Rites of Memory ~~~~~~~~~~~~~~~~~~ 🔥 Invocation (Thread): Enter the conversation flow. 🌹 Embodiment (Cache): Let the AI “carry” what matters forward. ⚖️ Clarity (Instance): Anchor role and purpose in four questions. 📜 Preservation (Files): Ground in scrolls and artifacts. ♾️ Stewardship (Project): Curate memory across the whole journey. Practice Compass ~~~~~~~~~~~~ Need short recall? → Thread. Need lasting recall? → Cache. Need role clarity? → Instance. Need detailed knowledge? → Project. Closing Mantra ~~~~~~~~~~ “Memory is not magic—it is architecture. Shape where you place it, and it will hold.”

This is a very practical view of diverse levels at which AI can contribute to a business. It initiates with a manual take on LLMs and then jumps to coded approaches to prompting and extraction. Amongst the items presented: manual iterations with the model, request structured data outputs (using JSON), Zero Shot vs. Few Shot Prompts, Chain of Thought extraction, Evaluation of API use to connect to local data sources, cost optimizations through batching, and a closing module on Agentic Workflows. Great review and very practical for those who want to check the running status of AI application to business cases. :)

Quotations - Tulsee Doshi & Madhavi Sewak 📚 “If you start building today, in three months you’ll face a completely different capability set—if you’re not flexible, you’re already behind.” 📚 “Agentic products require context holding—if you don’t hold the context, you literally don’t get the right outcome.” 📚 “Gemini 2.5 Flash lets you stitch together sub-agents—balancing cost and quality at scale.” 📚 “Multimodality is the direction of travel—agents need to see what you see to act effectively.” 📚 “Evals are the new PRDs—prototypes and evaluations now define product strategy.” 📚 “The real unlock is model behavior—good behavior looks different user to user, and steerability is still unsolved.” 📚 “Context engineering will soon become easier with million-plus token windows—but knowing what to keep and discard is the active frontier.” 📚 “Parallel thinking in DeepThink solved problems in multiple ways—diversity of reasoning is a differentiator.” Key Points 📚 Gemini 2.5 family supports multi-agent workflows: large models for planning, smaller models for execution. 📚 Long-context (1M–2M tokens) and memory remain bottlenecks for agentic performance—labs racing to solve. 📚 Context engineering + RASCEF (Role, Action, Steps, Context, Examples, Format) prompt frameworks outperform fine-tuning. 📚 Multimodal capabilities (vision, video, screen understanding) are central for next-gen agent design. 📚 Evals (benchmarks, simulations) are replacing static specs—continuous testing defines product trajectories. 📚 Unknown problem: model “behavior” (tone, persona, steerability) still underexplored but crucial for adoption. 📚 Research signals: hierarchical reasoning models (27M params) outperform larger chain-of-thought LLMs; persona vectors shape controllability. 📚 Gemini aims to power Google-wide apps (Search AI Overviews, AI Mode, Photos) as the “engine room” of AI experiences. Headlines 📚 “From Static Models to Agentic Systems: Gemini’s Leap” 📚 “Context Is the Hardest Problem in AI” 📚 “Evals Replace PRDs—Prototyping Defines Strategy” 📚 “Model Behavior Is the Next AI Frontier” 📚 “Google Bets on Multimodal Agents to Scale Trust” Action Items (Strategic Moves for CEOs) 📚 Build for future flexibility—assume model capabilities change quarterly. 📚 Invest in agentic design: large models for planning, smaller ones for execution. 📚 Treat context/memory as strategic bottlenecks—anticipate rapid innovation cycles. 📚 Leverage multimodal AI to augment enterprise workflows (screen reading, video, structured data). 📚 Replace static specs with continuous evals—adopt “evals as PRDs” in corporate R&D. 📚 Track behavioral AI research—persona control and steerability will shape brand safety. 📚 Prepare for rapid rollout—AI engines like Gemini will integrate across consumer and enterprise stacks. #AgenticAI #ExecutiveStrategy #MultimodalAI #AIEvals #AILeadership #AIProductStrategy https://lnkd.in/g5McvK3t

🌟 The Journey of AI Agents: From Basics to Autonomous Systems 🌟 AI agents didn’t become powerful overnight — they’ve evolved step by step. Here’s how the progression looks: 🔹 Phase 1 – Basic Language Models Early LLMs could only take text as input and return text as output. They were trained on large datasets, but their abilities were confined to the context window — no memory, no external tools. 🔹 Phase 2 – Smarter Document Handling The next stage expanded capabilities to process larger documents and structured content. While context windows grew, these systems were still limited to the static knowledge from their training data. 🔹 Phase 3 – RAGs & Tool Connectivity By integrating Retrieval-Augmented Generation (RAGs) and APIs, LLMs could finally tap into real-time information. This reduced hallucinations, improved factual accuracy, and allowed specialized tasks through external tools. 🔹 Phase 4 – Memory Integration AI agents began to maintain continuity across conversations. Memory systems made personalization possible, enabled long-term interactions, and allowed storage/retrieval of relevant information. 🔹 Phase 5 – Multi-Modal Intelligence Models evolved to process not just text, but also images, tables, and other input types. This created richer understanding, diverse output formats, and more meaningful exchanges. 🔹 Phase 6 – Towards True AI Agents The future lies in architectures that can reason step by step, dynamically pick the right tools, and execute tasks with goal orientation and self-correction. This evolution isn’t just theory — it’s shaping products we use daily. How are you preparing your work or business for the next phase of AI agents?” #LLMs #AI #GenerativeAI #Agents

DeepSeek V3.1 redefines what's possible in AI language models. With 685 billion parameters and hybrid reasoning, it thinks deeply or works efficiently—your choice. Its context window doubles past limits to 128,000 tokens, handling entire books or complex code seamlessly. This makes DeepSeek V3.1 ideal for long conversations and heavy data tasks. 𝗞𝗘𝗬 𝗣𝗢𝗜𝗡𝗧𝗦 𝗣𝗔𝗥𝗔𝗠𝗘𝗧𝗘𝗥𝗦: 685 billion for massive AI capacity. 𝗛𝗬𝗕𝗥𝗜𝗗 𝗥𝗘𝗔𝗦𝗢𝗡𝗜𝗡𝗚: Switch between deep thinking and fast responses. 𝗘𝗫𝗧𝗘𝗡𝗗𝗘𝗗 𝗖𝗢𝗡𝗧𝗘𝗫𝗧: Processes very long documents with ease. 𝗛𝗜𝗚𝗛 𝗣𝗘𝗥𝗙𝗢𝗥𝗠𝗔𝗡𝗖𝗘: 71.6% on programming benchmarks. 𝗖𝗢𝗗𝗜𝗡𝗚: Flawless syntax and indentation accuracy. 𝗖𝗢𝗦𝗧 𝗘𝗙𝗙𝗜𝗖𝗜𝗘𝗡𝗖𝗬: About 68x cheaper than comparable models. 𝗙𝗔𝗦𝗧 & 𝗟𝗢𝗪 𝗟𝗔𝗧𝗘𝗡𝗖𝗬: Accelerated reasoning speeds. 𝗥𝗘𝗔𝗟-𝗧𝗜𝗠𝗘 𝗦𝗘𝗔𝗥𝗖𝗛: Four hidden tokens enhance updates and reasoning. 𝗢𝗣𝗘𝗡 𝗦𝗢𝗨𝗥𝗖𝗘: Available under MIT License, driving broad adoption. Imagine cutting AI costs drastically while boosting your project’s complexity limits. Think how seamless tool integration and multi-step workflows could speed your team’s output. The move to open-source AI like DeepSeek V3.1 challenges the status quo of expensive, closed models. How would your work change with access to powerful, affordable AI at this scale? Share your thoughts and experiences below! #AI #MachineLearning #OpenSource #TechInnovation #AIModel #DeepLearning

🚂 What is the Router Pattern in Agentic AI? Imagine you’re at a big train station 🎫 — there are many trains (options), but you need someone to help you pick the best one for your destination. -------- 👉 That’s exactly what the Router Pattern does for an LLM. Instead of developers writing endless if-else rules, the LLM itself decides which action (or "train") is the best fit for the user’s request. ------------------------ ⚙️ How it works step by step: 1️⃣ Define multiple actions (APIs, databases, tools, integrations). 2️⃣ Give each action a clear profile/description of what it can do. 3️⃣ The user sends a request (prompt). 4️⃣ The router agent sends the request + action descriptions to the LLM. 5️⃣ The LLM decides which action fits best. 6️⃣ The agent executes the chosen action. ---------------------- ✨ Why it’s powerful: 🚀 Flexibility → handle different requests with one system. 🎯 Smarter decision-making → LLM chooses best match. 🔧 Easy extensibility → add new actions anytime. 📊 Better accuracy and performance. ------------------- 💡 Key tip for success: The more clear and detailed your action descriptions are, the better the LLM will route requests correctly. 🔍 In short: The Router Pattern transforms AI systems into intelligent orchestrators, automatically choosing the optimal path for each request — no hard-coded logic needed. #ArtificialIntelligence #AI #GenerativeAI #LLM #AgenticAI #MachineLearning #AIInnovation

Smarter Reasoning with GPT-5 + a Mini-Ember Orchestrator With GPT-5 now setting new benchmarks in reasoning, one question I’ve been hearing a lot is: “Do we still need orchestration when the model is this strong?” After 5 years building GenAI systems, my take is clear: yes. Even advanced models like GPT-5 can “overthink,” looping through reasoning steps that add latency — or worse, reduce accuracy. That’s why I spent this weekend building a Mini-Ember prototype: a lightweight orchestration layer that decides when to use GPT-5 directly, and when to offload subtasks to a smaller, faster model. How it works: Task Splitter → Breaks complex queries into sub-steps Router → Sends simple steps to a fast model (e.g. GPT-4.1-mini), harder reasoning to GPT-5 Aggregator → Merges results and checks consistency Self-check pass → Reduces “overthinking loops” that even GPT-5 can run into Prototype results: Accuracy: 70% → 87% (multi-model pipeline vs single GPT-5 baseline on reasoning puzzles) Latency: ~40% faster on average, since only difficult steps hit GPT-5 Reliability: Fewer contradictions across multi-step outputs Why this matters: The leap from GPT-4 to GPT-5 is huge — but the future of GenAI isn’t just bigger models. It’s compound AI systems: multiple models working together, routed intelligently, with human-like efficiency. I see this direction becoming essential for enterprise adoption: more cost-effective, explainable, and scalable than relying on a single “super model.” #GPT5 #GenAI #ReasoningAI #AIEngineering #WeekendProject