Posts

The hype around AI coding tools needs a reality check.

One of the leading AI copilots I tried went so far as to invent an API. It started building an app around this imaginary API and even pointed me to “documentation” that didn’t exist—completely fabricated.

I then pointed it to the correct documentation, thinking it would recover. Instead, after “reading” it, the copilot fabricated another API. That was the moment I stepped back.

I genuinely wanted it to work. But reality hit—these tools still struggle once the problem goes beyond boilerplate.

Leaderboards and benchmarks may look impressive, but they don’t capture what happens when you try to build real applications. In practice, copilots:

-> Shine at small, repetitive tasks.
-> Struggle with abstraction, system integration, and real-world constraints.
-> Often add more debugging than acceleration.

Unless you’ve been through the full cycle of designing, coding, and deploying with these tools, you won’t see the gap between demo performance and production reality.

I’m preparing a detailed breakdown from the app I’ve built—and will share soon. This will help manage expectations and shape how we think about building with these tools.

🤖💳 What if your AI agent could walk into the marketplace, bargain like a pro, and pay instantly on your behalf—all while following the exact rules you set?

That’s the future Agentic Commerce promises, and Google’s newly announced Agent Payments Protocol (AP2) is the scaffolding to make it real.

🔑 Why AP2 matters
-> Mandates with intent → Digitally signed instructions ensure agents act only within your authorization.
-> Payment flexibility → From credit cards to bank transfers to stablecoins (via the x402 crypto extension).
-> Delegated autonomy → Agents can act later (e.g., buy below a price threshold) without constant oversight.
-> Accountability by design → Every transaction leaves a verifiable, auditable trail.

🌍 The bigger picture
-> Trust unlocks adoption: AP2 addresses the #1 blocker — fear of losing control over payments.
-> New models emerge: Autonomous travel booking, dynamic deal-hunting, subscription management.
-> Interoperability at scale: Backed by 60+ partners across payments, fintech, merchants, and crypto.

⚠️ What to watch
-> Regulatory alignment across geographies.
-> User clarity in understanding what exactly they are authorizing.
-> Merchant adoption costs and readiness for crypto/stablecoin rails.

💡 My take: This isn’t just about payments. It’s about building the trust framework for agentic ecosystems, where AI doesn’t just answer queries but executes real-world transactions safely and transparently.

Read more @ https://lnkd.in/dXxRzU8S

#AP2 #google #agents Google

🤖 AI Copilots: 10 Realities of AI Copilots You Should Know

AI copilots are changing the way we work — coding faster, drafting smarter, analyzing quicker.

But like every breakthrough, they come with important realities to manage.
Here are the Top 10 truths about AI copilots that matter in practice 👇

1️⃣ Hallucination Happens
Copilots can be confident… but not always correct. The real skill is knowing when to trust, and when to verify.
2️⃣ Context is Everything
The best copilots are only as good as the data you give them. High-quality, secure context = high-quality outcomes.
3️⃣ The Hidden Cost Curve
Each interaction consumes compute. At scale, “small tasks” can quietly grow into big bills.
4️⃣ Impact Beyond the Screen
Every AI response requires energy. As usage rises, organizations are starting to measure and optimize that impact.
5️⃣ Human + AI = Balance
Copilots accelerate work, but human judgment keeps it meaningful. Over-reliance risks eroding critical skills.
6️⃣ A New Security Frontier
From prompt injections to hidden data leaks, copilots introduce new attack surfaces that demand vigilance.
7️⃣ Bias Scales Fast
What’s in the data flows into the decisions. Without guardrails, bias can be amplified in seconds.
8️⃣ Beyond the Chatbox
Real value comes when copilots integrate seamlessly into workflows — not just as a side window.
9️⃣ Governance Matters
Clear ownership, audit trails, and accountability frameworks are still catching up with how copilots are used.
🔟 Expectations Shape Experience
They are powerful assistants, not sources of ultimate truth. Setting the right expectations ensures adoption, not frustration.

AI copilots aren’t just tools — they’re work companions. The leaders who succeed will be those who combine innovation, governance, and human oversight to unlock their full potential.

AI Doesn’t Think — And That’s Why It Fails in Surprising Ways

AI isn’t a brain. It doesn’t “understand” the way we do.
It predicts — the next best word, image, or action — at astonishing speed.

Even the new wave of reasoning models doesn’t change this.
They still predict — only now layering those predictions into step-by-step chains that look like logic.

And this is why AI fails.
AI will fail in unfamiliar territory, when there’s a lack of data, in ambiguity without context, and sometimes even with basic common sense.

Let me share one of my own experiences.
While working on an application, AI generated overly complex code — even though a much simpler alternative existed. It didn’t use the latest APIs either, and even when I pointed it to new documents, it couldn’t infer the better approach.

Why? Because the model had no awareness of simplicity, relevance, or context.

From building many AI apps, I’ve learned that unless you apply your own judgment, the output may look correct but still be far from optimal. That’s where your experience comes in — you may have solved a similar problem in a better way before, or you have the intuition to infer that things could be made simpler. The judgment and real thinking can’t be replaced, and that’s exactly the paradox of AI: brilliant when patterns are rich, brittle when patterns are thin.

But here’s the key: if you understand this, you can leverage it.
-> Use AI where patterns and data are strong.
-> Feed the patterns you observe, fine-tune where needed, and apply human judgment to bridge the gaps.
-> That’s how prediction becomes power.

Next time you’re impressed (or alarmed) by AI, pause and remember:
It’s not magic — it’s prediction, analysis, and processing at a speed no human brain could match.

And that ability to turn raw data into instant output may be the most magical thing of all — especially when paired with human intelligence.

💡 What’s been your biggest AI surprise (good or bad)? 👇

💡 These 10 strategies for Generative AI can help organizations save cost, reduce carbon, and optimize energy use — while ensuring systems scale responsibly and remain regulation-ready.

📄 Download the full document here 👇

🌍 Sustainable AI: 10 Actionable Strategies
AI is advancing at an incredible pace — copilots, agentic workflows, and large-scale deployments are becoming the norm. But as AI adoption accelerates, so does the conversation around responsibility, efficiency, and long-term resilience.

The latest edition of the newsletter dives into 10 actionable strategies for Sustainable AI — a practical playbook for organizations looking to innovate responsibly while staying ahead of the curve.

This isn’t about waiting for regulations. It’s about mindset, competitive advantage, and building AI systems that scale efficiently, responsibly, and sustainably. #sustainableai #greenai #ai Green Software Foundation

📩 Read the full blog in the latest newsletter here 👇

🌍 The Hidden Cost of AI at Scale: It’s Time for a Sustainable AI Playbook

Most reports focus on the cost of a single prompt in terms of energy — but that misses the bigger picture.

The real challenge? Billions of prompts running daily. Multi-agent workflows looping across models. Workloads distributed globally. These small inefficiencies compound into massive energy, carbon, and cost burdens that are reshaping our infrastructure demands.

A Sustainable AI Playbook helps address this by embedding sustainability at every stage of the AI lifecycle:
🔹 Design with Responsibility – Minimize unnecessary complexity, choose the right model size, and optimize code for efficiency.
🔹 Measure What Matters – Apply standards like the upcoming Software Carbon Intensity (SCI) framework for AI to track emissions across training, inference, and operations.
🔹 Carbon-Aware Operations – Run workloads where and when clean energy is available, right-size infrastructure, and optimize scheduling.
🔹 Lean Agentic Workflows – Balance autonomy, collaboration, and tool use while keeping cost, carbon, and complexity under control.
🔹 Governance & Accountability – Establish sustainable AI guidelines for development and deployment, policies, guardrails, and transparent reporting to ensure sustainability goals are consistently met.
🔹 Culture of Green AI – Build awareness, training, and accountability across teams to make sustainability part of everyday AI practices.

💡 Sustainable AI isn’t just about reducing emissions — it’s about making AI efficient, resilient, and responsible at scale, while also lowering operational costs.

#sustainableai #leanagenticai #greenai Green Software Foundation

🚫 Never Start with Code — That’s Not How You Work with AI.
It’s tempting.
You open your favorite AI assistant.
You type: “Build a login page with OTP.
And it delivers. Fast.

But here’s the truth:
👉 Starting with code is the fastest way to build the wrong thing — beautifully.
Because when you lead with code, you:
🔹 Get locked into the first idea, not the best one
🔹 Accept hallucinations: fake APIs, unstable logic, random packages
🔹 Ignore trade-offs: security, performance, energy, and maintenance
🔹 Create complexity that’s hard to unwind

🧠 We need to move from Copilot to CoThinker
AI shouldn’t just generate code.
It should help you reason.

Before you even ask for code, ask:
💬 What’s the problem I’m solving?
🧠 What are 2–3 ways to solve it?
⚖️ What matters most — performance, security, or sustainability?
🧰 What’s the right language, package, or design for this context?
Only then should the AI assist you — not replace your thinking.
✅ CoThinking in Action

Here’s a better workflow:
🔍 Define intent — not just instructions
🧱 Break down architecture before code
⚡ Model trade-offs (speed, energy, complexity, emissions)
🔐 Prioritize security, reliability, and sustainability
✍️ Let AI code — but you stay in control

💡 Code is easy part. Clarity is rare.
The future of software is not Copilot.
It’s CoThinker.
Not just typing faster — thinking better.

Sam Altman recently shared that some people are now using ChatGPT like therapy or life coaching. While he welcomed this exploration, he also warned about a small group of users who struggle to separate fiction from reality. The message is clear: AI should support mental well-being—not replace human connection or reinforce delusions.

🔹 Two years ago, I explored this concept in my book “The AI Life Coach: Personal Growth and Transformation with the Power of Generative AI”. The core idea remains deeply relevant today.

Life is a series of questions.
From the moment we wake to the time we rest, our minds ask—How do I grow? Lead better? Respond with empathy? We’ve always leaned on mentors, books, conversations, and experiences to guide us.

Now, AI offers something new: a thinking partner—available anytime, equipped with the world’s knowledge, offering guidance in seconds. But here’s the key:
AI can help you think better—not think for you.
Human wisdom stays the anchor; AI is the amplifier.

📖 Through practical scenarios and real-life examples, I explore how you can use AI to:

• Reflect on your decisions
• Improve emotional awareness
• Ask better questions
• Strengthen leadership habits
• Make value-aligned choices

🔸 But how you use it matters:
✨ Set clear intent when seeking answers
✨ Interpret responses with curiosity, not blind faith
✨ Take action based on your values, not just AI suggestions
✨ Seek real-world feedback and human counsel
✨ Protect your emotional space—AI isn’t a therapist

Used well, AI becomes a companion for personal growth. Misused, it can blur boundaries and disempower judgment. The balance lies in awareness and intentional use.

👉 Get your copy of AI Life coach at Amazon : https://lnkd.in/dnnKxx2h

⚠️ While LLM providers keep increasing context window sizes, designing for long context windows isn’t the right approach.

Here’s why:
🔹 Inefficiency at Scale
Bigger windows mean more tokens per request. That adds overhead without delivering proportional gains in reasoning or outcomes.
🔹 Noise Over Signal
Feeding everything into the model doesn’t ensure better answers. Longer contexts can blur what’s truly relevant, leading to weaker responses.
🔹 Memory Management & Loss of Context
Models still struggle with remembering and prioritizing information over long spans. Extending the window doesn’t solve the deeper challenge of structured memory.
🔹 Smarter Patterns Exist
Techniques like retrieval-augmented generation (RAG), summarization, structured memory, and lean agentic workflows provide sharper, more reliable results.

💡 The principle is simple: design for the right context, not the longest one.
Every unnecessary token adds cost, compute, and carbon overhead.

👉 One practical advice: always design systems with constraints in mind — that’s where true efficiency emerges. For context windows, think: how would you solve the problem if you only had a smaller window available? That mindset pushes you toward leaner, more efficient solutions. #leanagenticai

GPT-5 is teaching us patience… and maybe even reflection.

I’ve been using GPT right from the early days, but their latest thinking model got me thinking.

How do I describe GPT-5?
It doesn’t rush to fill silence. It doesn’t leap to the first answer. Instead, it pauses. It lingers. What could have been spoken in five seconds, it stretches into thirty—not from hesitation, but from reverence for reflection.

And in that pause lies something new: it gives humans the opportunity to think the answer along with it. That’s what makes GPT-5 feel less like a tool, and more like an AI companion—inviting us to share the process rather than just consume the result.

Some might call it slow. I’d call it mindful. While earlier models sprinted, GPT-5 strolls. And in that stroll, it reminds us that not every answer needs to arrive instantly—sometimes, wisdom prefers to be fashionably late.

Don’t take this seriously 🙂
The future version will hopefully be fast—you would have waited long enough.

The true test of Agentic AI isn’t how much it can do — it’s how efficiently, responsibly, and sustainably it can do it.

🎙️ Tune in to my latest episode of Agentic AI: The Future of Intelligent Systems — “Designing Lean Agentic AI: Principles for Sustainable Autonomy.

In just 6 minutes, this episode explores how to design energy-efficient agentic AI systems that deliver results while minimizing cost, carbon, and complexity:

1. Goal Clarity & Planning Depth — the foundation of purposeful autonomy.
   Purposeful Tooling & Models — select the right tools and model tiers; route to smaller models when possible.
2. Efficient Reasoning — manage reflection depth, control reasoning loops, and cut unnecessary tool calls.
3. Retry Strategies — resilience with capped retries and smart backoff instead of wasteful repetition.
4. Memory & Learning — scoped, purposeful memory that supports intelligence without excess overhead.
5. Supporting Resource — free white paper for a deeper dive.

If you’re building AI for impact, this episode shows why lean design is the real path to cost-effective, energy efficient and sustainable autonomy.

▶ Listen here: https://lnkd.in/dAcBrDY7

💡 This is part of a growing series—now over 50+ episodes—on how to design agentic AI systems that are efficient, responsible, and future-ready. If you’re new, you can always catch up with the earlier episodes to dive deeper into the journey.

👉 Follow the podcast for more deep dives and practical insights on shaping the future of intelligent systems.

Google’s latest paper on measuring the environmental impact of AI at scale is an important step forward. It’s the first time we’re seeing production-grade reporting of Gemini Apps serving metrics—and credit to Google for bringing this transparency to the industry.

The numbers stand out:
0.24 Wh of energy per prompt
0.03 g CO₂e per prompt
0.26 mL of water (about five drops)

On their own, these impacts seem tiny. But scale changes everything. If AI prompts begin to replace traditional search queries, we’re looking at at least 1 billion prompts per day. That translates to 240 MWh of energy, 30 tons of CO₂, and 260,000 liters of water daily. At full search scale (~14 billion queries daily), the footprint becomes grid-level and industrial in magnitude.

And that’s just for text prompts. As usage shifts toward multimodal prompts—text-to-image, text-to-video, and more—the per-request footprint will be significantly higher. Add in Agentic AI workflows, where multiple models, tools, retrieval calls, and reasoning loops are orchestrated for a single outcome, and the cumulative impact grows even further.

While the report focused on text prompts, it showed a 33× reduction in energy and a 44× reduction in emissions over one year—a reminder of how important continued efficiency gains will be as AI expands into more resource-intensive multimodal and agentic use cases.

Check out the technical paper here: https://lnkd.in/djFw265T

One point to note: the report presents market-based emissions, which credit clean energy procurement. It would be equally valuable to see location-based emissions, reflecting the actual grid mix where workloads run.

Google’s broader Carbon Footprint tools already show both market-based and location-based emissions side by side. Extending that same dual reporting to AI serving would provide even more clarity and comparability for the ecosystem.

While providers will continue to improve efficiency at the infrastructure and software/model level, it is equally important to design applications in a lean way—minimizing cost, carbon, and complexity, improving energy efficiency, and playing our part. That’s the mindset I explore in detail in my book: leanagenticai.com

#google Green Software Foundation #sustainability

Faster. Leaner. Cost-Effective. Cleaner.

That’s what I’m seeing while experimenting with Rust on Google Cloud Run — now officially supported.
The early results:
✅ Cold starts are fast
✅ Memory usage stays low
✅ CPU time is efficient
✅ Container sizes are small

Since Cloud Run bills by CPU, memory, and execution time, these improvements directly reduce cost per request.

But there’s more.

Less compute used also means less energy consumed.
At scale, this translates to meaningful reductions in both cloud cost and carbon impact.

If you’re running high-throughput services or latency-sensitive APIs, this combination of performance and sustainability is worth looking into.

As the Rust cloud ecosystem matures and more libraries become available, adoption will only grow.

And remember—you don’t need to rewrite everything in Rust.
Start small. Introduce Rust where it brings measurable impact.

If the internet transformed how businesses connect,
AI agents will transform how businesses think.

Nobody talks about internet protocols or servers anymore.
We just use them—silently powering how every business runs.

That’s where AI agents are heading.
They’re not tools.
They’re not models.
They’re not “GPT vs Gemini.

Agents are not the technology.
They’re the intelligence layer—built on top of it.

They plug into workflows, take action, learn from results, and improve over time.
Like a teammate who never stops getting better.

Think about the early days of the internet:
You didn’t wait for the “best” browser or protocol.
You picked what worked, went live, and evolved as tech matured.

It’s the same with agents.

Don’t get caught up chasing the biggest model or the shiny new tool.
Don’t wait for perfect.
Start by designing agentic workflows that solve real problems—using what you already have.

Because the underlying tech will keep changing.
What matters is how you design around it.

The winners won’t be the ones with the latest stack.
They’ll be the ones who started building intelligence into their systems—now.

Agentic AI is moving fast, with new frameworks, orchestration models, and multi-agent workflows appearing every month. Organizations that rely only on off-the-shelf setups risk locking into vendor-driven decisions that may not fit their cost, carbon, compliance, or capability goals.

Organizations need to build their own Agentic AI capability, a foundation they own, control, and can adapt to changing business and technology landscapes — and one that safeguards and leverages their data as a strategic asset.

Three steps to make it happen:

1. Define Your Agentic Blueprint
   Map out the use cases, decision-making logic, and integration points. This blueprint should reflect your business priorities, risk appetite, data policies, and performance metrics.
2. Select and Assemble Core Components
   Choose models, toolchains, and orchestration layers with portability in mind. Incorporate routing, cost-aware execution, sustainability controls, and data protection measures from the start to avoid expensive rewrites later.
3. Establish Continuous Adaptation Loops
   Agentic systems do not stay optimal forever. Set up monitoring, feedback, automated tuning, and data quality checks so your agents can evolve with new information, regulations, and market shifts.

Do not wait for regulations. Build now with transparency, accountability, and resilience. Build a system you can stand behind before someone else decides the rules for you.

This 10-Step Agentic AI Lifecycle shows how to build production-ready AI agents that balance performance, cost, carbon, and compliance.

It moves beyond toolchains into adaptive, goal-driven systems that can reason, collaborate, and operate with measurable business value — while remaining ethical, auditable, and sustainable.

Inside, you’ll find practical design patterns for:

1. Defining Purpose & Metrics that align with both outcomes and ESG goals
2. Designing Lean Architectures with scoped roles, efficient workflows, and controlled memory
3. Choosing the Right Models & Tools to avoid over-provisioning and cut emissions
4. Embedding Reasoning & Planning with transparent decision logic and human oversight
5. Continuous Monitoring & Governance to ensure trust, traceability, and readiness for audits

The lifecycle is grounded in a banking loan underwriting use case — showing exactly how to deliver fast, fair, and environmentally conscious AI decisions at scale.

📄 Download the full report to explore all 10 steps in detail and apply them to your own AI initiatives.

OpenAI GPT-5 introduced two powerful new parameters via the Responses API:
→ reasoning.effort – controls how deeply GPT-5 thinks before generating a response
→ text.verbosity – adjusts how detailed and long the final output is

I ran an experiment using a real-world scenario prompt:
🧪 “Should a retail bank build or buy an agentic AI onboarding system?

Across 12 combinations of reasoning effort (minimal, low, medium, high) and verbosity (low, medium, high), I tested how GPT-5 responds.

🔍 Key Discoveries — applicable across domains, not just banking:

✅ Reasoning Effort controls how much thinking happens before answering:
– Minimal: very shallow; fastest, but lacks useful depth
– Low: quick and light; good for getting an initial sense of the topic
– Medium: balanced thinking and speed; great for most use cases
– High: deep analysis; best for complex reasoning and strategic thinking

✅ Verbosity affects how much detail is shared in the answer:
– Low: simple, clear, executive-style summaries
– Medium: balanced content with clear explanations (default)
– High: rich, detailed outputs; best when paired with high reasoning effort

🎯 Effective combinations by purpose:
Initial exploration → low effort, low verbosity
Executive briefing → high effort, low verbosity
Strategy development → high effort, medium verbosity
Documentation/training → high effort, high verbosity
Everyday analysis → medium effort, medium verbosity

💡 Why it matters:
The new Responses API gives you levers to control how deeply GPT-5 reasons and how clearly it communicates.
If you’re migrating to the new responses API, don’t just copy your prompts over.
Tune the reasoning and verbosity levels to match your audience, context, and cost-performance goals. Getting this balance right can make all the difference between surface-level output and strategic insight.

I’m making the Lean Agentic AI repository available to help teams design agentic systems that are efficient, sustainable, and scalable from day one.
Agentic AI has massive potential — but without a lean approach, it can quickly spiral into runaway cost, carbon, and complexity.

This repository distills practical patterns to:

• Identify and eliminate inefficiencies in multi-agent workflows.
• Treat cost, carbon, and complexity as first-class metrics.
• Apply lean principles to prompts, model selection, planning depth, tool usage, memory, and execution timing.
• Build systems that deliver results without waste.

📂 Access the Repository:
https://lnkd.in/dp8KZVku

Build lean now, or pay for it later — in cost, carbon, and complexity.

Has the recent GPT-5 upgrade started making your existing projects hallucinate? You’re not alone.

Anyone using the ChatGPT web interface has likely felt the impact. I have multiple inflight projects that were running smoothly until the upgrade starts hallucinating for follow-up questions. Attached is an example of a real hallucination.

If you’re scrambling to recover, here’s one quick fix:
Switch back to the GPT-4o model while it’s still available and get your work done.

Steps: Go to Settings → Enable “Legacy Models” → Select GPT-4o.

This is a temporary solution, but it helps restore stability for now.

Good engineering practices still matter—especially when upgrading to models with new behavior and parameters. Rolling out breaking changes without clear migration paths has a real impact on projects already in flight.

If you’re mid-project, make the switch while GPT-4o is still accessible.

How has the recent GPT-5 upgrade affected your work?