Posts

🚀 What if your stock portfolio could analyze itself?

I’ve published an experimental project that automates investment portfolio analysis by connecting three powerful technologies: Zerodha KITE MCP, CrewAI, and Large Language Models.

The open-source repository (https://lnkd.in/d_BtqyCy) demonstrates how to build an autonomous system for financial insights.

How It Works:
🤖 Autonomous Agents (CrewAI): A team of AI agents manages the entire workflow, from secure login and data fetching to the final analysis.
🛠️ Seamless Integration (Zerodha MCP): The agents use Zerodha’s Model Control Protocol directly to interact with trading and account functions—no complex API integration needed.
🧠 AI-Powered Analysis (LLMs): Once your holdings are retrieved, a language model performs a deep-dive analysis, highlighting concentration risks, surfacing top/bottom performers, and offering actionable suggestions.

This isn’t just about retrieving data; it’s about creating an “intelligent agent” that provides automated, bespoke portfolio advice. The template is simple to clone and extend for much deeper quantitative and qualitative analysis.

This is a powerful use case for agentic AI in finance, and I’m just scratching the surface.

🔗 Check out the repository and see it in action: https://lnkd.in/d_BtqyCy

I’d love to hear your thoughts. What other financial tasks could be automated with an agentic workflow like this?

In the era of AI, engineering isn’t about stepping back—it’s about stepping up to new responsibility.

To remain relevant and drive real impact, the skills that matter most aren’t about writing every line of code, but about mastering the art of orchestration—knowing what to delegate, what to own, and how to guide intelligent systems with purpose.

As Gen AI, co-pilots, and agentic systems become part of daily work, success comes from knowing what to delegate and what to own.

🔹 Define the What:
Set clear objectives, boundaries, and success criteria. Your role is to articulate goals, design workflows, and ensure intent is understood by both AI and people.
Example: When deploying a co-pilot, you determine the specific coding challenge it should address, select which parts of the codebase are in scope, and establish what a successful solution looks like—such as passing all tests and following team conventions.

🔹 Guide the How:
Shape not just the process, but the AI’s thinking and orchestration—decide when prompts should be open-ended to foster creativity and when they should be precise for control. Guide how different tools, agents, and humans interact. Steer AI in unfamiliar territory, especially with new frameworks or domains the model hasn’t learned yet. Craft prompts, review outputs, and intervene decisively where only human expertise can fill the gap.
Example: In an agentic workflow for document automation, you design how an AI agent extracts data, when to escalate to a human for review, and how to route exceptions. If your co-pilot encounters a new library, you provide detailed guidance and supplement its output to match the organization’s needs.

🔹 Own the Why:
Remain accountable for the results. Validate, interpret, and monitor outcomes—always making sure that every decision supports business value, ethics, and user needs.
Example: After deploying a Gen AI-powered support chatbot, you continuously review user interactions, monitor for environmental impact, safety, fairness, and accuracy, and step in when the system produces unintended or biased responses—ensuring the experience aligns with business standards and ethical guidelines.

In this new landscape, engineering means orchestrating intelligent systems with purpose and responsibility. The future belongs to those who define, guide, and own their impact at every stage.

Fear. Anxiety. Uncertainty.
These feelings have become all too common in engineering as artificial intelligence, Gen AI, and agentic workflows reshape everything we know about building and leading in tech. But real transformation always starts in the mind. A new era demands a new mindset—one that turns fear into curiosity, uncertainty into strategy, and every challenge into an opportunity for growth.

But what if these emotions aren’t roadblocks, but invitations?
Invitations to rethink our skills, evolve our roles, and step into new kinds of influence.

That’s why I wrote The New AI Engineering Mindset: Navigating Uncertainty and Opportunity in the Age of Intelligent Machines—a practical roadmap for turning apprehension into agency.

This book goes beyond the hype. It equips engineers and leaders with frameworks, applied examples, and the Human Stack model—helping you navigate rapid change, harness Gen AI and LLMs responsibly, and lead with clarity in uncertain times. It also covers an in-depth case study on transforming the Software Development Lifecycle (SDLC) using Gen AI and Agentic AI—providing actionable insights for every role across the engineering spectrum.

If you’re ready to move from anxiety to action, and to help define the next era of engineering, I invite you to explore this book and join the conversation.
Inside the book, you’ll find:
🔘 Practical playbooks for thriving as an engineer in the age of AI
🔘 Strategies for overcoming anxiety and adapting to rapid technological change
🔘 A candid look at job disruption, automation, and how to remain indispensable
🔘 The Human Stack model for future-ready roles and leadership
🔘 In-depth frameworks for ethical AI, prompt engineering, and responsible deployment
🔘 A holistic case study on transforming SDLC with Gen AI and Agentic AI
🔘 Tips for building community, fostering collaboration, and supporting each other—because we’re all in this together
Let’s transform uncertainty into opportunity—together.

➡️ Explore “The New AI Engineering Mindset” here: https://amzn.to/3ZQyLwy

What if the future of work isn’t about humans versus AI—but about humans moving up the stack? The newest edition of Technology Bytes explores the eight-layer Human Stack, redefining how people interface with, augment, and elevate intelligent systems.

Discover how roles like Context Engineers, AI System Composers, Behavioral Calibrators, Responsibility Anchors, Trust & Certification Leads, Legal/IP Guardians, Sensemakers, and Visionaries create new domains of value—grounded in human judgment, creativity, and stewardship.

Climbing the Human Stack: where technology ends, true human value begins.

👉 Read the full newsletter and explore the various roles.

Certifying Agentic AI: Rethinking Assurance for Evolving Intelligence

As intelligent systems advance, so must the way we measure their trustworthiness. Traditional certification approaches—built for static code and predictable workflows—no longer fit a world where AI agents reason, adapt, collaborate, and act on context.

Certification for Agentic AI isn’t just a box to check. It’s a new discipline. Reliability can’t be frozen in a single moment or test. Instead, it must be continuously evaluated:
🔹 How does an agent reason and delegate?
🔹 Can it self-correct?
🔹 When should it refrain from acting?
🔹 Does it operate within clearly defined boundaries?
🔹 How does it handle conflicting goals or ambiguous instructions?
🔹 Can it explain its decisions in a way that makes sense to humans?
🔹 Is it capable of recognizing its own limitations—and escalating when necessary?
🔹 How does it maintain trust and transparency when collaborating with other agents or external systems?
🔹 What guardrails exist to prevent emergent or unintended behaviors?
🔹 How is ethical and operational alignment maintained as the agent evolves over time?

Certifying these systems means asking new questions, embracing continuous validation, and evolving our standards alongside the agents themselves.

For a deeper dive into this crucial shift, tune in to my latest episode of the Agentic AI podcast: “Certifying Agentic AI: Rethinking Assurance for Evolving Intelligence.

Link - https://lnkd.in/duXft9sq

🧠 Can Co-Pilots Truly Learn New APIs on the Fly? AI coding assistants—or “Co-Pilots”—have become powerful accelerators for development. But here’s a real-world challenge many developers are now facing: 👉 Ask them to write code using a newly released API or framework, and you often get:

• Outdated references
• Incorrect method signatures
• Fabricated classes that don’t exist Yes—hallucinations in code.

Why does this happen?
Because most Co-Pilots are trained on past data. If the framework is new—or if internal documentation isn’t publicly indexed—these tools fall back on best guesses based on similar patterns. That’s where things go wrong.

🔍 So how do we fix this?

• Augment AI with live documentation lookups
• Integrate retrieval-based agents that pull from up-to-date API specs
• Enable dynamic feedback loops so the model learns what worked, and what failed

We’re entering a phase where the future of developer productivity hinges not just on Co-Pilot capabilities, but on how context-aware and adaptable they are to change.

The next-gen coding assistant shouldn’t just autocomplete—it should continuously learn, adapt, and validate.

As Agentic AI transitions from labs to live environments, it brings not just promise—but unprecedented complexity. These aren’t just programs; they’re systems that plan, decide, and act autonomously.

This shift calls for a new design imperative: security by architecture, not afterthought.

Our latest newsletter unpacks the real risks and outlines practical design strategies for securing next-gen autonomous systems.
📖 Read the blog to explore how to build trustworthy, resilient Agentic AI.

Agentic AI is shifting from proof-of-concept to strategic capability. But for it to be enterprise-ready, it must evolve—fast. It’s no longer enough for agents to plan, reason, and act.

Enterprises demand systems that are secure, efficient, observable, and accountable. Here’s what enterprise-ready Agentic AI really means: 🔒 Security by Design

• Role-based execution and permission control
• Tool-level sandboxing and isolation
• Safe tool invocation and prompt injection prevention 💸 Cost Control and Efficiency
• Lean prompt engineering and selective memory
• Dynamic model routing (SLM > LLM when feasible)
• Token-aware orchestration and call limits per agent/task 📈 Performance at Scale
• Real-time responsiveness in agent chains
• Lightweight planning loops with controlled recursion
• Caching, precomputation, and optimized memory usage 🌱 Sustainability and Green Software
• Emission-aware agent design (based on GSF SCI principles)
• Green prompting and clean energy-aware execution
• Monitor compute cost + optimize for energy efficiency ✅ Trust, Auditability, and Governance
• Full observability of agent decisions and tool usage
• Explainable reasoning paths and deterministic fallbacks
• Human in the loop (when required) and compliance reporting (AI Act, SOC2, internal audits) 📊 Visibility and Observability
• Dashboards for memory, latency, and token usage
• Workflow heatmaps and traceable agent behavior
• Integration with enterprise AIOps and monitoring systems

✅ Agentic AI must now be lean, secure, explainable, and scalable.

It’s not about building more agents. It’s about creating the right ones—that last, that scale, and that earn trust.

🔍 For a deeper dive into designing cost-, carbon-, and complexity-efficient agentic systems, do visit https://leanagenticai.com

🤖 As Agentic AI scales, four problems surface fast:

1. 💸 Cost Spiral – Too many agents, too many model calls, too much billing.
2. 🌍 Carbon Bloat – Redundant reasoning, memory inflation, and wrong model choices burn unnecessary energy.
3. 🔄 Complexity Creep – What starts as smart orchestration turns into tangled, unmanageable workflows.
4. 🚧 Lack of Guardrails – No control over when to use heavy models or which tools to trigger, leading to inefficient execution.

We need to design autonomy that’s efficient, not excessive.

That’s where Lean Agentic AI comes in — a mindset and methodology to build agentic systems that optimize cost, carbon, and complexity. It means choosing the right-sized models, designing workflows with intention, reducing unnecessary memory/state, and adding smart guardrails to avoid runaway invocations.

To help developers, architects, and researchers get started, I’ve created a public repo explaining the core concepts of what “lean” really means in the context of agentic AI—covering principles, pitfalls, and design patterns.

🔗 GitHub Repo – Lean Agentic AI
https://lnkd.in/dp8KZVku

The repo includes byte-sized learnings, practical strategies, mental models, and architectural insights.

For a deeper dive into building cost, carbon, and complexity-efficient systems— 📘 Refer to my book: Lean Agentic AI – Cost, Carbon, and Control
(Linked in the repo and available worldwide via Amazon)

Let’s build agentic systems that are lean by design, responsible by intent.

📄 MCP vs A2A – Protocol Comparison for Agentic AI

As agent-based systems scale, two key protocols are shaping how AI agents communicate and operate:
🔹 Anthropic’s Model Context Protocol (MCP) – Ideal for enhancing a single agent with dynamic tool access and contextual grounding.
🔸 Google’s Agent-to-Agent (A2A) Protocol – Designed for agent collaboration, delegation, and decentralized orchestration.

This one-page PDF provides a crisp comparison across 15 core features — from architecture to security to real-world applicability.
📥 Download the visual PDF below.

#mcp #a2a Anthropic Google

Lean Agentic AI Principles – Minimize Cost • Carbon • Complexity
Build AI that’s lean by design, not bloated by default.

Agentic AI unlocks powerful capabilities—but without the right principles, it can become expensive, inefficient, and hard to scale.

This visual guide introduces foundational strategies to design efficient, effective, carbon-aware, and purpose-driven agentic systems.

From smart memory use to carbon-aware orchestration, each pattern focuses on doing more with less—without compromising intelligence or impact.

📄 Explore the guide and design with cost, carbon, and control in mind.
Stay tuned for more insights on Lean Agentic AI.

📌 Every major tech wave starts the same way—rapid innovation, competing tools, and a race for adoption— until one thing consistently reshapes the landscape: standardization.

What we’re seeing with Agentic AI today isn’t new—it’s déjà vu. Let’s rewind:

🔍 Web Era (Search Engines & SEO):
Early web discovery featured search engines like AltaVista, Yahoo!, and Lycos.
Then came Google, redefining relevance, introducing keyword bidding, and creating a structured SEO economy that transformed online visibility.

🔗 API Era (SOAP, REST):
Software integrations were once built on varied protocols—CORBA, XML-RPC, SOAP—each with different implementation models.
REST simplified the landscape with stateless design and broad adoption, becoming the foundation of the modern API economy.

📱 Mobile Era (Platforms to App Stores):
Mobile apps initially ran on diverse platforms—Palm OS, Symbian, BlackBerry OS, and Windows Mobile—each with its own development tools and delivery models.
Then came Apple’s iOS and Google’s Android, offering unified environments.
With the App Store and Google Play, mobile development was transformed—standardizing discovery, monetization, and updates.

🤖 Agentic AI Era (Frameworks to Protocols):
Today, we see a growing number of agent frameworks—LangChain, AutoGen, CrewAI, LangGraph—each shaping its own vision of agentic workflows, memory, and orchestration.
At the same time, protocols like Anthropic’s MCP and Google’s A2A are emerging to standardize how agents interact and collaborate, much like REST did for APIs and app stores did for mobile.
The next evolution is the rise of agent marketplaces—the AI equivalent of the App Store or Play Store—where agents and tools are composed dynamically to complete tasks and deliver outcomes, standardizing how we discover, deploy, and monetize autonomous capabilities.

If you’re feeling overwhelmed by the pace—new models every week, frameworks launching daily, everyone racing to define the future—relax.
The model race, the framework race, the agent race—it will all settle. It always does.Standardization brings clarity. And with it, scale. This is the natural rhythm of tech evolution.

And if AI follows the same arc of consolidation we’ve seen in every prior wave…
What do you think it will become— the operating system, the interface, or the infrastructure of tech?

🌍 Code runs everywhere. So does its environmental impact.
From AI to UI, from cloud choices to code structure — every decision we make in software design affects energy, carbon, and sustainability.

This isn’t about adding another checklist. It’s about shifting the mindset.
Attached is a visual deck of Green Software Principles — practical ideas that apply across roles, tools, and technologies.

Let’s build systems that are not just smart — but sustainable.

#GreenSoftware #SustainableTech #ClimateAction #AI #Cloud #SoftwareEngineering #DigitalSustainability Green Software Foundation

🎯 Google cloud launches Agent Development Kit (ADK) to Simplify Multi-Agent Development.

The ADK provides an open-source framework for building multi-agent AI applications with control, modularity, and integration in mind.

ADK supports both deterministic pipelines and LLM-driven workflows, allowing developers to define structured and adaptive agent behaviors. 🔘 Multi-Agent Composition – Build modular applications by chaining or nesting agents 🔘 Model Control Protocol (MCP) – Connect tools, models, and data sources securely 🔘 Apigee Integration – Use existing business APIs directly within agent workflows 🔘 Tool Ecosystem – Extend agents with built-in tools, custom logic, and external libraries 🔘 Evaluation Framework – Debug and test with built-in evaluation tools 🔘 Flexible Deployment – Deploy agents locally, on Kubernetes, or using Vertex AI 🔘 Connected Intelligence –

• Access 100+ pre-built connectors
• Use Application Integration workflows
• Connect to AlloyDB, BigQuery, NetApp — without data duplication

🚀 Getting Started with ADK
Install the SDK, explore documentation, and start with examples:
🔗 Documentation & Tutorials - https://lnkd.in/dFW7XYvC

ADK provides a practical path for building scalable agent-based systems with built-in connectivity and control.

#GoogleCloudNext #AIDev #NewTech #ADK #GoogleCloud Google Cloud

🎥 The video attached is generated using Veo 2, announced at Google Cloud Next 2025 — showcasing just a glimpse of what’s now possible with generative video.

Here’s the prompt that brought it to life:
A cinematic video of a large-scale tech conference, Google Cloud Next 2025, in a grand convention center. Show diverse attendees arriving, registering, networking, and walking past booths with vibrant digital signage. Transition to a packed keynote hall with dramatic lighting. Cut to breakout sessions with developers coding on laptops, enterprise leaders in panel discussions, and immersive demos of generative AI tools and cloud infrastructure. Show an AI like human robot taking a breakout session. Create a wide-angle view of the venue’s exterior, lit up at night, with banners that read ‘Google Cloud Next 2025 – The Future is Now.’ Realistic animation, dynamic camera angles, energetic music, and natural crowd motion throughout.

🪄 With Veo 2, it’s more than just video generation — it’s about:

• Extending frames
• Inpainting/outpainting
• Cinematic shot composition and pacing
• Visuals that match your brand tone and context
• Responsible AI

Paired with Lyria for text-to-music, the result is a cohesive, AI-augmented creation experience — where your ideas shape both visuals and sound.

📌 Business applications? From quick concept videos to consistent, scalable brand storytelling.

Remember: AI doesn’t know what to create until you prompt it.
It’s not automation — it’s augmentation.

We’re entering the age of AI-native content pipelines — flexible, fast, and fully prompt-driven.

#Veo2 #Lyria #GoogleCloudNext2025 #GenerativeVideo #TextToMusic #VertexAI Google Cloud #DeepMind #GoogleCloud #AIHypercomputer

Lean Agentic AI Principles – Minimize Cost • Carbon • Complexity
Build AI that’s lean by design, not bloated by default.

Agentic AI unlocks powerful capabilities—but without the right principles, it can become expensive, inefficient, and hard to scale.

This visual guide introduces foundational strategies to design efficient, effective, carbon-aware, and purpose-driven agentic systems.

From smart memory use to carbon-aware orchestration, each pattern focuses on doing more with less—without compromising intelligence or impact.

📄 Explore the guide and design with cost, carbon, and control in mind.
Stay tuned for more insights on Lean Agentic AI.

Excited to share the release of my latest book – Lean Agentic AI: Minimizing Cost, Carbon, and Complexity
📘 https://leanagenticai.com/

I’ve written several tech books over the last two decades—but this one is different. It’s not just another AI book. It’s a mindset shift. The first to focus entirely on designing agentic systems that are lean, efficient, cost-effective, carbon-aware and responsible from the ground up.

When I built my first agent, the focus was on orchestration—chaining steps, calling models, getting results. But as things scaled, it became clear: the system was overthinking, overspending, and overconsuming—on autopilot.

The industry keeps chasing bigger models, longer context windows, and leaderboard scores. But here’s the truth:
💬 “Intelligence without discipline leads to waste.

This book introduces new and practical concepts—like Purpose-Bound Reasoning, Model Minimalism, Cost-centric design, Memory Cost Index, Elastic Intelligence, and Lean Workflow Design—all aimed at making autonomy efficient, not excessive.

🔍 What You’ll Find Inside
💰 A clear view of the cost and carbon impact of agentic systems
Understand how seemingly simple workflows quickly become energy-intensive, driving up operational costs,
🧠 The root causes of waste in AI agents
Explore how prompt design flaws, uncontrolled loops, poor model choices, and lack of feedback loops lead to inefficiency and cost escalation.
⚙️ Design principles for building lean agentic systems
Apply fewer agents, smaller models, dynamic routing, tighter prompts, and caching strategies—without compromising output.
📊 Evaluation of leading frameworks
Learn how CrewAI, LangGraph, and AutoGen differ in control, resource awareness, and energy impact.
🌍 Deployment strategies for efficient operations
Use green regions, scale responsibly, and build carbon-aware infrastructure choices into agent design.
📉 Examples and patterns that work
Real-world strategies to reduce token usage, cap API calls, and maintain balance between autonomy and control.
🔮 And more …
Design for cost efficiency, Green agents, carbon dashboards, and systemic sustainability monitoring inside agentic pipelines.

If you’re building or scaling agentic systems, this book was written with you in mind.

Let’s reimagine intelligence—leaner, smarter, and truly sustainable.

🧠 Most agentic AI systems today are overthinking, overspending, and overconsuming—on autopilot.

This edition uncovers why smarter agents don’t mean bigger models or longer memory. In fact, that mindset may be the trap.

Lean is not less. Lean is what makes autonomy sustainable.
📥 Click to read the latest newsletter:
“Rethinking Agentic AI: Why Lean Is the New Smart

🖼️ Ghibli-Style Generations - What if your AI-generated art came with an energy label?
Social media is overflowing with stunning Ghibli-style AI creations—soothing scenes, magical creatures, timeless vibes. But here’s the hidden layer most users never see:
⚡ Behind every dreamy prompt is real compute.
🌍 Behind every scenic output is a carbon cost.
🧠 Behind every “generate” click, a resource is consumed.

Most users don’t know.
And why would they?
There’s no meter. No alert. No visibility.
🤔 Why don’t Gen AI systems display a basic energy or emission estimate—just like nutrition labels or price tags?
Not to stop creativity.
But to inform it.
Not every generation is heavy. Not every user will care.
But some will, if we give them the choice to know.

🎨 Ghibli-style art celebrates nature.
Let’s honor that by making digital creativity more transparent—and more sustainable.

Because when awareness becomes default, sustainability becomes a choice.

In fact, OpenAI’s CEO, Sam Altman, recently revealed:
“We’ve been growing a lot and are out of GPUs.” (source: yahoo news)
This highlights the immense computational power required for such AI models—leading to significant energy consumption and environmental impact.

Trends will keep changing.
Today it’s Ghibli-style. Tomorrow it’ll be something new.
But building awareness now would shape how responsibly we create—no matter what trend comes next.

#GenerativeAI #GreenAI #ResponsibleCreation #GhibliStyle #SustainableDesign #TransparencyInAI #CarbonFootprint #DigitalAwareness #OpenAI Green Software Foundation

Choosing the right agentic framework isn’t just about features — it’s about how your agents think, plan, and act.

In 2025, the diversity in AI agent frameworks reflects their core philosophies — from minimalist code-first loops to graph-based workflows and decentralized simulations.
How agents think and act varies by framework:
🔁 LangChain – Chain-of-thought prompts
💬 AutoGen – Asynchronous message-driven agents
📋 Semantic Kernel – Planner-skill execution model
👥 CrewAI – Role-based pipelines
📊 LlamaIndex – Workflow graphs with shared context
💻 SmolAgents – Code-first agent loop
📐 PydanticAI – Structured, validated outputs
🌐 AgentVerse – Agents in simulated environments

Cloud-native frameworks are also shaping enterprise AI adoption:

• Microsoft AutoGen (Azure) – Scalable, async agents with OpenAI integration
• Amazon Bedrock Agents – Native orchestration using AWS tools & functions
• Google Vertex AI Agents – Grounded generation + data-aware agents
• IBM Watsonx Orchestrate – Low-code agents for business process flows

I’m working on a detailed multi-dimensional comparison covering:
🔹 Execution models & coordination
🔹 Tool use & memory integration
🔹 Scalability strategies & deployment readiness
🔹 LLM interoperability & extensibility
🔹 Business impact, ROI potential & real-world adoption patterns

If you’d like an early copy of the draft, drop a comment below 👇