In a previous hands-on articles, we built agents using local LLMs, and another article hands-on with AI-Integrated Development Environment using Claude Code. This article continues that journey,

Here the focus is different:

👉 How Claude Code becomes an Agent Platform — not just a coding assistant.

In this article, we will teach Claude how to work with us. We will progressively build: Skills, Agents, MCP tools, Plugin integrations amd by the end, Claude will act as: an About-Me agent, a Books price agent, and an externally powered MCP agent

This article is a fast practical foundation before deeper automation.

1. Starting a Claude Code Workspace

Create a fresh workspace:

mkdir cc-practices
cd cc-practices
cloude

Claude starts and loads configuration automatically and logs into if ANTHROPIC_API_KEY exists in environment.

Refer earlier article for mode details on setup. Complete source code is available at Github.

2. Understanding The Brain of Claude Code

Claude reads instructions from a file named: CLAUDE.md, and it act as it’s brain.

It can exist:

• project root
• subfolders
• .claude/ directory

👉 Nearest file wins.

This is extremely powerful. Instead of prompting repeatedly, you define permanent behavior.

To generate initial context run forward slash “/” - commands.

❯/
  /init                   Initialize a new CLAUDE.md file with codebase documentation
  /statusline             Set up Claude Code's status line UI
  /add-dir                Add a new working directory
  /agents                 Manage agent configurations

/init will scan the repository, understand structure. generate documentation automatically and create .claude/ configuration.

This commands are default skills, let’s add more skills to claude.

3. Claude Skills — Lightweight Agent Capabilities

Skills are the simplest form of agent behavior.

They live inside: .claude/skills/

A skill is essentially: 👉 a reusable operational prompt

Example: .claude/skills/about-me/SKILL.md

/about-me skill

# about-me skill
Fetch and present information about a known person or topic by retrieving content from their associated URL.

## Supported Queries
The following names map to URLs:
| Query | URL |
|-------|-----|
| Kuldeep Singh | https://thinkuldeep.com/about/ |
| Kuldeep Singh's books | https://thinkuldeep.com/about/books/ |
| Elon Musk | https://en.wikipedia.org/wiki/Elon_Musk |

## Instructions
1. Read the `$ARGUMENTS` to determine who or what the user is asking about.
2. Look up the matching URL from the table above.
   - If no match is found, respond: "No information available for: <query>"
3. Use the WebFetch tool to fetch the matched URL.
4. Extract and present only the plain-text paragraph content from the page, limited to the first 2000 characters.
5. Summarize or present the fetched content as a direct answer to the user's question.

Use this skill as command prompt

❯/about-me Kuldeep Singh
❯/about-me Kuldeep's books

It would return response like below

⏺ Fetch(https://thinkuldeep.com/about/books/)
⏺ Books by Kuldeep Singh
  Kuldeep Singh has authored and contributed to several publications:
  Authored Books:
  - Jagjeevan: Living Larger Than Life — A heartfelt tribute to the extraordinary life and timeless wisdom of Shri Jagguram, combining personal recollections with life lessons across ten chapters on heritage, resilience, responsibility, and
  gratitude.
  - Exploring the Metaverse — A comprehensive guide to the metaverse and the future of the internet, examining opportunities and challenges in emerging digital spaces.
  - My Thoughtworkings — An ebook launched during Thoughtworks' 30th anniversary, featuring insights from thirty employees including Kuldeep, reflecting on what shaped his professional journey.

Similarly, book_price skill got added, and we can ask book price now

❯ /book-price Jagjeevan, India

Claude now reads skill definition, Calls WebFetch, Extracts information, and Responds

No prompt engineering required anymore. However, Claude may use skill in response to a natural prompts as well.

We have created a reusable capability, but these are not agents, they are good for single shot. Let’s build Claude Agents.

4. Claude Agents — Autonomous Reasoning

Now we move to real Agentic AI. Agents live in: .claude/agents/

Example: .claude/agents/about-me.md

This is very similar to what we built as ReAct Loop in earlier article

Thought → Action → Observation → Answer

Find the Agent Source — about-me.md

Just reload the Claude, and it must be listed in : /agents, cloud would use it in with natural prompts as instructed.

❯ books writen by kuldeep using subagent about-me

⏺ about-me(Fetch books by Kuldeep)
  ⎿ Done (2 tool uses · 5.4k tokens · 17s)
  (ctrl+o to expand)

⏺ Here are the books listed on Kuldeep Singh's page:

Written by Kuldeep Singh
 1. Jagjeevan: Living Larger Than Life — A tribute to Shri Jagguram covering themes of heritage, resilience, responsibility, and values. Described as a practical guide for a meaningful, value-driven life.
  2. Exploring the Metaverse — A comprehensive guide addressing the metaverse as the future of the internet, examining opportunities and challenges while emphasizing individual agency in shaping its evolution.
  3. My Thoughtworkings — An ebook created for Thoughtworks' 30th anniversary, featuring guiding thoughts from 30 colleagues that shaped Kuldeep's professional and personal journey.

Note:- We are providing instruction to use subagent in the prompt, to avoid Claude picking matching skill we added earlier. Otherwise, explicit mention is not needed.

Similarly, we added an agent to fetch book price, and get the price with naturally.

❯ get price of Jagjeevan and Exploring the Metaverse using subagent
❯ total price of these books
⏺ books-agent(Calculate total book prices)
⎿ Done (3 tool uses · 8.9k tokens · 35s)
(ctrl+o to expand)
⏺ Here are the total prices for both books in India:

Focus is not on prompting, but to design AI behavior here…

This completes porting our earlier agent into Claude Code, let’s move next advanced topic.

6. Introducing MCP — Model Context Protocol

Skills and Agents still rely on Claude’s internal tools.

MCP changes everything.

MCP allows: 👉 external programs to become native Claude tools.

MCP Server Configuration

.claude/.mcp.json

{ 
  "mcpServers": {
    "about-me": {
      "command": "python",
      "args": ["about-me-mcp-server.py"]
    }
  }
}

or register mcp server.

claude mcp add about-me python about-me-mcp-server.py

Restart Claude.

What the MCP Server Does

The Python server — about-me-mcp-server.py:

• exposes an about(query) function
• fetches websites
• parses HTML
• returns structured data

Claude now calls: mcp__about-me__about() instead of WebFetch as instructed in .claude/agents/about-me-mcp.md

❯ tell about Kuldeep Singh using agent about-me-mcp
⏺ about-me-mcp(Tell about Kuldeep Singh)
⏺ Here's what the about-me MCP tool returned about Kuldeep Singh:
  ---
  Kuldeep Singh is a technology leader with a "Tech@Core" approach, empowering businesses through innovation.
  Current Role
  - Global Emerging Technology Leader & Principal Consultant at Thoughtworks
  Professional Background
 ...

Here Claude invoked MCP tool, retrieved structured data, produced answer as per the agent. With this

we just connected Claude to a custom backend capability.

7. Claude Plugins — Packaging Capabilities

Next evolution:

👉 package MCP tools as reusable plugins.

Example: about-me-toolkit/.claude-plugin/plugin.json

Plugin defines:

• tools
• arguments
• install instructions
• MCP configuration

Install:

pip install -e about-me-toolkit

8. The Architecture Evolution — The Shift

What we built progressively:

LevelCapabilitySkillPrompt automation, Single instruction, No reasoning loop and Fast automationAgentAutonomous ReAct reasoning, Multi-step decisions, Context awarePython AgentCustom execution loop, Multi-step decisions, Context awareMCP ToolExternal system integration,Language-agnostic, Reusable across clientsPluginReusable AI capability distribution

However the bigger realization is Claude Code is not an IDE feature.

It is becoming: An operating system for AI agents.

We don’t just ask questions. We design: behaviors, capabilities, workflows and intelligence boundaries

Think in layers: Prompt → Skill → Agent → Platform

Most developers stay at prompt level. Agentic engineering starts when you move beyond it. The real shift is not AI generating code.

The shift is: Developers designing intelligent systems that can act.

Claude Code provides one of the clearest paths today to move from: 👉 using AI to 👉 building with AI agents.

What Comes Next

In upcoming parts we will explore:

• Multi-agent orchestration
• Persistent memory
• Local + Cloud hybrid agents
• Long-running background agents
• Production agent governance

🔗 References

https://github.com/aipractices/ai-agents https://thinkuldeep.com/post/agentic-ai-hands-on/ https://thinkuldeep.com/post/agentic-ai-hands-on-2/ https://www.udemy.com/course/ai-agents/ https://medium.com/@rodrigo.estrada/build-a-local-ai-coding-assistant-qwen3-ollama-continue-dev-cee0dbcd172a https://kulkarnishreenidhi.medium.com/building-a-local-ai-agent-with-python-a-practical-implementation-guide-b45f71cffdfb

Claude Code for Agentic AI: From Foundations to Real Agents was originally published in AIPractices on Medium, where people are continuing the conversation by highlighting and responding to this story.

In Agentic AI Hands-On — Part 1, we built our first AI Agent and explored how a well-designed prompt can drive real-world actions — browsing websites, calling APIs, or performing calculations through tools.

We implemented the agent using the basic architecture

Thought → Action → Observation → Reasoning → Answer

Where the agent relied on OpenAI LLMs hosted over cloud and accessed through a python SDK. While powerful, this setup requires:

• an API key
• internet connectivity
• a paid cloud account

In this article, we will build the same Agentic AI system using local open-source models — running entirely on your machine

Following the below architecture.

Hosting Local LLMs with Ollama

Ollama allows you to run Large Language Models locally, similar to ChatGPT, OpenAI — but without cloud dependency.

👉 Think of Ollama as Docker for AI models
Download → Run → Chat → Build locally

Getting Started with Ollama

• Install

$ brew install ollama

• Start the service:

$ ollama serve

• Pull a model: (on other terminal)

$ ollama pull llama3

• Run the model

$ ollama run llama3  
$ >>> What is capital of India   
  The capital of India is New Delhi.

💡Tips

• 💡Ollama automatically uses your Mac’s GPU (Metal acceleration) for better performance on Apple Silicon.
• 📦 Models are stored under ~/.ollama/models.
• llama3 is 4.7GB model, best in class, however if we want speed and good general purpose laptop, we may find better option like phi3, deepseek-coder, gemma:2b, qwen2.5:7b, etc based on the needd
• Ollama exposes a local HTTP API: http://localhost:11434

👤 Using Ollama in the About-Me Agent

In the previous hands-on, we created an agent that answers questions about a person (in this case, me ) by fetching real data from a source instead of hallucinating.

Example query:

You: Who is Kuldeep Singh?
You: Books from Kuldeep?

Previously we used:

client = OpenAI(api_key=openai_key)

Now we replace it with a local Ollama chat call.

Ollama Agent Client

OLLAMA_URL = "http://localhost:11434/api/chat"
LLM_NAME = "llama3"

class Agent:
    ...
    def execute(self):
        response = requests.post(
            OLLAMA_URL,
            json={
                "model": LLM_NAME,
                "messages": self.messages,
                "stream": False,
                "options": {
                    "temperature": 0,
                    "num_predict": 1024
                }
            },
            timeout=1200
        )
        response.raise_for_status()
        return response.json()["message"]["content"]

The About-Me Agent Prompt

The agent behaviour remains identical. Only the LLM backend changes. about-me-agent.md

You operate using an internal loop:
Thought → Action → Observation → Answer

Think before answering.
Use tools when information is required.
Wait for Observation after every Action.
Provide final Answer only when sufficient information exists.

Available Tool:
Action: about: <query>

Detailed file can be found on the git source..

The tool simply retrieves trusted context: about: query?

about_map = {
    "Kuldeep Singh": "https://thinkuldeep.com/about/",
    "Kuldeep Singh's books": "https://thinkuldeep.com/about/books/",
}

Running the Agent

$ python about-me-agent/about-agent-local.py 
  You: kuldeep's book

The agent:

1. reasons about the request
2. calls the about tool
3. receives observation
4. generates the final answer

Result:

✅ Final Answer: Kuldeep Singh has authored three notable books:
   Jagjeevan: Living Larger Than Life,
   Exploring the Metaverse,
   My Thoughtworkings - The guiding thoughts that work for me.

We achieved the same capability as OpenAI — fully local.

📚Books Agent using Ollma

Similar way, let’s extend the concept for the Books agent we built earlier, the agent that can:

• fetch books price from respective site pages — Exploring The Metaverse and Jagjeevan
• perform calculations
• combine multiple tool results

The system prompt includes -

Available Tool:

Tool Name: book_price
- Description: returns the price of book in given country. use default country india.
- Format: `Action: book_price: <book name>, <country>`
- Example: `Action: book_price: Exploring the Metaverse, India`

Tool Name: calculate
- Description: Runs a calculation and returns the number - uses Python so be sure to use floating point syntax if necessary
- Format: `Action: calculate: expression`
- Example: `Action: calculate: 4 * 7 / 3`

Agent Workflow

The agent autonomously:

• Retrieves price of Book A
• Retrieves price of Book B
• Calculates total
• Returns final answer

Example query:

Check total price of Exploring the Metaverse and Jagjeevan in India

python books-agent/books-agent-local.py
You: price of exploring the metaverse and jagjeevan in india

✅ Final Answer:
 The total price of Exploring the Metaverse and Jagjeevan in India is ₹1041.

Performance Reality: Local vs Cloud Models

The result matches OpenAI — but execution takes longer.

Why?

Local models trade:
✅ Privacy
✅ Zero API cost
✅ Offline capability

for
❌ Higher latency
❌ Hardware dependency

Choosing the Right Ollama Model

Try different models:

ollama pull phi3:mini
ollama pull qwen2.5:7b

Then switch:

LLM_NAME = "qwen2.5:7b"

response = requests.post(
            OLLAMA_URL,
            json={
                "model": LLM_NAME,
                "messages": self.messages,
                "stream": False,
                "options": {
                    "temperature": 0,
                    "num_predict": 1024
                }
            },
            timeout=1200
        )

Model => Result

lama3=> Accurate but slower
qwen2.5:7b => Best balance
phi3:mini => Fast but hallucinated

You can further tune:

"options": {
             "temperature": 0,
             "num_ctx": 4096,
             "num_predict": 300,
             "num_gpu": 1
          }

Local models improve continuously — but cloud APIs still lead in speed and reasoning reliability.

Key Learning

Agentic AI is not about the model alone.

It is about:

• structured prompting
• reliable tools
• controlled execution loops
• strong engineering foundations

Switching from OpenAI → Ollama required almost zero agent redesign.

🚀 What’s Next

• Memory & long-term context
• Multi-agent collaboration
• Production failure patterns
• Observability for AI agents

🔗 References

https://github.com/aipractices/ai-agents https://thinkuldeep.com/post/agentic-ai-hands-on/ https://www.udemy.com/course/ai-agents/ https://www.youtube.com/watch?v=cZaNf2rA30k

Agentic AI using Local LLM Setup was originally published in AIPractices on Medium, where people are continuing the conversation by highlighting and responding to this story.

The world of technology is evolving at lightning speed. Every week, new AI models, frameworks, and services make headlines. With the hype around LLMs, Agentic AI, MCPs, and A2A systems, it’s easy to feel like we’re always playing catch-up.

But here’s the truth: without strong fundamentals, chasing the “next big thing” is like building a skyscraper on sand. A strong foundation ensures stability. That’s why, before diving deep into Generative AI, it’s critical to revisit the path that got us here.

This article is structured as a learning guide — a quick explainer — so you can use it to build the right base for your GenAI journey (and even prepare for AI/GenAI certifications).

We’ll cover the evolutionary path:

Machine Learning → Deep Learning → Generative AI → NLP → Speech → Computer Vision → Agentic AI

1. Machine Learning (ML): The Starting Point

At its core, machine learning (ML) is about teaching machines to learn from experience, just as humans do. Models are essentially mathematical equations trained on large datasets to predict outcomes (labels) based on given inputs (features).

The process of building ML models involves training on datasets, adjusting parameters, validating results on test data, and repeating this cycle until the results are satisfactory.

Two primary techniques define ML:

• Supervised learning: where we have labeled data with known outcomes.
• Unsupervised learning: where no labels exist, and the machine must find hidden patterns or groupings.

1.1 Supervised Machine Learning

It is generally built on historical observations where we have clear relation between outcome (label — y) and parameters ( x1, x2, x3…). and a model can be derived to represent that relationship in a mathematical form the model.

y = f(x1, x2, x3, …)

With this, we can predict outcomes for new data.

• Regression is used when predicting numeric values (e.g., predicting rainfall based on temperature and wind speed).
• Classification is used when predicting categories (e.g., diagnosing diseases from patient records). Binary classification: two categories (true/false, positive/negative). Multiclass classification: more than two categories.

Key steps in supervised learning include:

• Splitting data into training and test sets.
• Applying algorithms like Linear Regression (for regression) or Logistic Regression (for classification).
• Evaluating results using techniques such as confusion matrices, F1 score, MAE, MSE, or R².
• Iterating until results reach an acceptable accuracy.

1.2 Unsupervised Machine Learning

In contrast, unsupervised learning deals with data that has no labels. The goal is to uncover structure and relationships hidden within the data.

A common technique is K-Means clustering, where data points are grouped into clusters based on similarity. The algorithm keeps adjusting centroids until the clusters stabilize.

Evaluation here involves measuring separation between clusters — using metrics like silhouette scores or distances from cluster centers.

In many real-world scenarios, hybrid approaches combine supervised and unsupervised methods, allowing clusters to be labeled and then used for prediction tasks.

2. Deep Learning: Inspired by the Brain

Deep learning takes ML a step further by mimicking how the human brain processes information through neural networks.

Each artificial neuron applies a function to inputs, weighted by importance, and passes the output through an activation function to decide whether the signal continues.

Through repeated training (epochs), weights are adjusted using methods like gradient descent until errors are minimized. Networks with many layers are called deep neural networks (DNNs), which can handle complex tasks in regression, classification, natural language, and computer vision.

3. Generative AI: The Creative Leap

Generative AI (GenAI) represents a leap forward. Unlike traditional ML, it doesn’t just predict — it creates. With natural language prompts, GenAI can produce text, images, code, audio, and more. We have covered Generative AI Fundamental in recent article on Building Gen AI solutions.

FOMO to Flow: Building Gen AI Solutions

The evolution here is tied to natural language processing (NLP):

• Early methods relied on tokenization and embeddings to represent words numerically.
• RNNs allowed sequential predictions but struggled with long contexts.
• Transformers revolutionized NLP by enabling parallel processing and introducing attention mechanisms.

This led to powerful tranforer architectures like:

• BERT (encoder-based, by Google) for understanding context.
• GPT (decoder-based, by OpenAI) for generating coherent content.

Today’s LLMs are built on these foundations. Gen AI advancement has good impact on traditional AI ways of natural language, audio processing, and computer visions.

4. Natural Language Processing (NLP)

Core NLP tasks include:

• Language detection
• Sentiment analysis
• Named entity recognition
• Text classification
• Translation
• Summarization
• Conversational AI

Many cloud providers now bundle most of these into ready-to-use services over LLMs, but understanding the underlying mechanics helps us better use and evaluate them.

5. Speech Processing

Modern speech systems convert speech to text and text to speech in real time. Thanks to deep neural networks, today’s synthetic voices sound natural — closing the gap between human and machine communication.

These capabilities power applications in accessibility, customer support, and live transcription.

6. Computer Vision

Computer vision enables machines to interpret visual information. Traditionally, convolutional neural networks (CNNs) dominated this field, excelling at tasks like image classification, object detection, and segmentation.

But now, transformers and multimodal models extend these abilities further. By combining image encoders with text embeddings, models can understand and generate across modalities — describing images in natural language or generating images from text.

7. Agentic AI: The Next Stage

Agentic AI systems can not only process information but take autonomous actions, chaining multiple models and tools together.

• Example: AI agents booking a flight, writing an itinerary, and syncing your calendar — without manual intervention.
• Built on strong ML, DL, and GenAI foundations.

Conclusion

Generative AI is redefining how we interact with technology, but the path here matters. Without grounding in ML, DL, NLP, and CV, it’s easy to misuse or overestimate GenAI.

Think of this journey as layers of a course:

• ML (prediction)
• DL (complex data handling)
• GenAI (creation)
• NLP, Speech, CV (specializations)
• Agentic AI (autonomy)

✨ Certification Tip: Most GenAI certifications (from Google, Microsoft, AWS, or Stanford/DeepLearning.AI) expect you to understand this progression, not just how to call an API.

By stepping back, reinforcing fundamentals, and then advancing, we ensure that our GenAI journey isn’t just hype-driven — but future-ready.

A Path to AI → GenAI → Agentic AI was originally published in AIPractices on Medium, where people are continuing the conversation by highlighting and responding to this story.

Earlier, with our patented AppSpace method, we enabled rendering a phone’s 2D apps in 3D on smart glasses. But we found a gap — there was no direct way for a 2D app (like Chrome) to interact with 3D spatial content.

🏅 Thrilled to share that our solution to this is now recognized with a U.S. Patent!

Patent No : US 12,373,174 B2

This patent, titled _“IDENTIFICATION OF CALLBACK FROM 2D APP TO RENDER 3D MODEL USING 3D APP” granted to Lenovo.

This invention enables seamless interaction between 2D apps and 3D models — for example, opening a Google AR Animal directly from Chrome into a smart glass environment.

🚀 Originally developed for Lenovo’s ThinkReality A3 smart glasses, this technology bridges the gap between flat screens and immersive spatial computing.

🚀This originally developed for Lenovo’s award-winning ThinkReality A3 smart glasses,

Detailed Guide on 3D Model Viewer here

👨‍💻 Honored to be one of the inventors alongside Raju Kandaswamy

🙏 Thank you to everyone who contributed to shaping this innovation and to Lenovo for the opportunity to bring meaningful technology to life.

☞ USPTO #17/820,017 ☞ JUSTIA #20240061657 ☞ Granted #12323679 ☞ More Details

Also covered by NIT Kurukshetra Alumni Association

Refer here for my more patents

Patent Granted: Spatially interact with 3D Model from a 2D app in the smart glasses was originally published in XRPractices on Medium, where people are continuing the conversation by highlighting and responding to this story.

India will host the AI Impact Summit 2026, reaffirming its commitment to making Artificial Intelligence (AI) accessible and beneficial for the public good. The event will explore how AI can address real-world challenges in healthcare, education, agriculture, climate change, and governance — building on the momentum of global gatherings like the AI Action Summit France, AI Seoul Summit, and AI Safety Summit.

As part of the lead-up to the summit, OpenUK and OpenHQ have been hosting pre-summit events to spark conversations around AI openness. These discussions were inspired by Prime Minister Modi’s remarks at the 2025 Paris AI Action Summit, where he emphasized the need for “access for all” through open-source AI.

I was honored to speak at “Road to the Indian AI Impact Summit — Openness and Access to All” in Delhi on August 11, 2025, joining leaders from communities, enterprises, and policy organizations to discuss the role of openness in AI.

Welcome & Keynotes

The day began with a welcome address from Hiren Parekh, followed by remarks from Reji Kumar Pillai, President of ISGF.

Young open-source developer Swastik Baranwal shared his inspiring journey in open technologies, calling for stronger industry support.

Amanda Brock introduced the India AI Openness Report, detailing India’s contributions to open-source AI, the growth of AI-related repositories, and the urgent need for broader access.

Panel 1: Creating AI for All Through Open Source & Digital Public Goods

Moderator: Amanda Brock
Panelists:

• Tarunima Prabhakar, Co-Founder, Tattle
• Kuldeep Singh, Principal Consultant, Engineering, Thoughtworks
• Ashish Tewari, Head, Infosys Responsible AI Office, India
• Rohith Reddy Gopu, Chief AI Officer, TYNBAY
• Joshua Bamford, Head of Tech & Innovation, UK High Commission, Delhi

We explored how India’s open digital infrastructure — like Aadhaar’s identity stack and the India Stack’s open protocols — can inspire an open AI ecosystem.

Key pillars of AI openness discussed:

• Open Source Software — More than a tech choice, it’s a strategy for scale, sovereignty, and self-reliance. True openness means reusable, well-documented, community-supported solutions.
• Open Models — Open-weight LLMs, speech, vision, and domain-specific models ensure independence from restrictive foreign APIs, while enabling language diversity and local innovation.
• Open Data — Well-governed, anonymized datasets representing India’s diversity are critical for training AI that reflects our realities, not just those of the Global North.

We also reviewed initiatives like Open Government Data (OGD) Platform India, National Data Sharing and Accessibility Policy (NDSAP), and AIKosha — and discussed how India can influence global AI governance to ensure systems are open, trusted, and interoperable. We also touched upon Bhashini, Bahmni and thoughtworks’s opensource contributions.

A major takeaway: “Open” doesn’t mean “free.” It requires awareness, trust frameworks, and safeguards to prevent misuse.

Panel 2: Energy, Infrastructure, Data Centres & AI

Moderator: Amanda Brock
Panelists:

• Reji Kumar Pillai, Chairman, India Smart Grid Forum
• Sandeep Chittora, Associate Partner, Management Consultant, KPMG
• Abhishek Ranjan, SVP & CEO, BSES Rajdhani Power Limited
• Hiren Parekh, Board Member, OpenUK

This panel revealed how Smart Grid India is leveraging AI, IoT, XR, and digital twins to build virtual grids, predict power consumption, and optimize transmission and distribution.

Key insights:

• India already has surplus power generation capacity — bottlenecks are in transmission and distribution.
• AI is being deployed to improve grid efficiency, forecast demand, and enhance data center operations.
• Green energy sources like solar and wind are being integrated with AI to optimize usage and reduce carbon footprints.

Conclusion

The pre-summit event reinforced a critical message: Openness in AI is not just a principle, it’s a catalyst for scale, trust, and innovation.

India’s approach — rooted in open-source, open data, and open models — can set a global example for building AI as a public good while respecting local realities.

A collective action is needed to ensure that AI serves everyone, not just a privileged few, very similar conclusion I have done in my book “Exploring the Metaverse”.

Exciting conversations ahead as we move toward AI Impact Summit 2026.

Speaker | Pre AI Impact Summit: Openness in AI

Openness in AI was originally published in AIPractices on Medium, where people are continuing the conversation by highlighting and responding to this story.