Introduction: the question we are not asking

Most conversations about Artificial Intelligence (AI) begin with a simple question:

How do we build a model as powerful as ChatGPT?

It is a reasonable question.

It is also the wrong question.

Nations do not become technologically sovereign because they possess the largest model.

They become sovereign because they own the systems beneath the model.

When we look at the history of strategic technologies, the lesson appears repeatedly.

A country does not become energy independent by building a power plant. It becomes energy independent by controlling fuel production, transmission infrastructure, engineering expertise, maintenance capability, and long-term research.

A country does not become militarily independent by purchasing aircraft. It becomes independent when it can design, manufacture, repair, upgrade, and deploy those aircraft without external permission.

Artificial Intelligence is no different.

Today, much of the world discusses AI as though it were a product.

In reality, AI is infrastructure.

And infrastructure is only sovereign when it continues functioning after external support disappears.

This distinction is becoming increasingly important.

The age of unrestricted globalization is ending. Export controls are expanding. Semiconductor access is becoming a geopolitical instrument. Software platforms increasingly reflect national interests. What was once considered a purely commercial ecosystem is gradually becoming strategic territory.

The question before India is therefore not:

Can we build a better chatbot?

The real question is:

Can India build an AI ecosystem that continues operating even when critical external dependencies fail?

This essay argues that the answer is yes.

But only if we stop thinking about AI as a race for bigger language models and start thinking about it as a civilizational infrastructure project.

The wake-up call

Many Indian developers experienced a small version of this reality over the last few years.

Tools became unavailable (Claude Fable/Mythos). Services changed policies (GitHub Education Plan). Regional restrictions appeared (Google Omni Models). Features vanished.

For an individual developer, these events were frustrating.

For a nation, they reveal something deeper.

A dependency that can be withdrawn is not ownership.

Modern software development relies on layers of infrastructure owned by foreign corporations:

• Code hosting platforms
• AI assistants
• Cloud services
• Training frameworks
• Accelerators
• Networking equipment

Most of the time this arrangement works perfectly.

Until it does not.

The purpose of sovereignty is not to prepare for normal conditions.

It is to remain functional during abnormal conditions.

That is why countries maintain strategic petroleum reserves.

That is why countries maintain food reserves.

That is why countries invest in domestic defense industries.

The same logic now applies to Artificial Intelligence.

What AI sovereignty actually means

The term “AI Sovereignty” is often misunderstood.

Many people assume it means building a local chatbot.

Others assume it means translating an existing model into Indian languages.

Neither definition is sufficient.

A sovereign AI ecosystem must satisfy a much stronger requirement:

It must remain operational even if external technological support disappears.

This requires control over four layers.

Layer 1: software sovereignty

The frameworks, compilers, kernels, and development tools that allow researchers to build models.

Layer 2: compute sovereignty

The physical infrastructure:

• Datacenters
• Networking
• Power systems
• Cooling systems
• Scheduling systems

Layer 3: model sovereignty

The ability to train, maintain, and deploy indigenous foundation models.

Layer 4: knowledge sovereignty

The ability to construct models that understand local reality rather than merely importing someone else’ s understanding of the world.

Most discussions focus on Layer 3.

The true challenge lies in Layers 1 and 2.

The great dependency trap

To understand the challenge, consider a simple machine learning program.

import torch

import torch. nn as nn

This looks harmless.

Behind these two lines sits an enormous global dependency chain.

A researcher writes Python.

Python is translated into mathematical operations.

Those operations are translated into hardware instructions.

Those instructions execute on specialized accelerators.

Those accelerators are manufactured using tools built by other companies.

Those tools rely on supply chains spanning multiple countries.

What appears to be a few lines of code is actually a geopolitical stack.

The most famous example is CUDA.

The CUDA problem

CUDA stands for Compute Unified Device Architecture.

It is the software layer that allows AI programs to communicate efficiently with NVIDIA graphics processors.

CUDA is one of the greatest engineering achievements of modern computing. It is also one of the largest concentration points of technological dependence. Over fifteen years, the global AI ecosystem optimized itself around CUDA. Researchers built libraries around CUDA.

Companies built products around CUDA.

Universities taught CUDA.

Startups hired CUDA engineers.

As a result, much of the world’ s AI infrastructure effectively speaks one language.

A language controlled by one company.

This creates strategic fragility.

If access to that ecosystem becomes restricted, entire research programs become difficult to sustain.

The lesson is not that CUDA is bad.

The lesson is that dependency becomes dangerous when alternatives disappear.

Software sovereignty therefore begins with portability.

The objective is not to eliminate NVIDIA.

The objective is to ensure that Indian AI research can survive without NVIDIA if necessary.

Why India cannot copy China

At this point, many people ask:

Why not simply do what China did?

The answer is straightforward.

China’ s path cannot be replicated directly.

China began investing heavily in semiconductor manufacturing decades ago.

It developed domestic firms.

It built fabrication capability.

It accumulated engineering expertise.

It stockpiled components before restrictions intensified.

Even then, the process remains difficult.

India is starting from a different position.

Attempting to reproduce China’ s entire semiconductor journey in three years would be unrealistic.

Fortunately, sovereignty does not require immediate semiconductor independence.

What India needs first is operational independence.

That distinction changes everything.

The sovereignty pyramid

Most countries approach AI upside down.

They start with the model.

The stronger strategy begins at the foundation.

World Models

▲

Foundation Models

▲

Compute Infrastructure

▲

Compilers & Software Stack

Every higher layer depends on the lower layers.

A nation that owns the bottom of the pyramid can eventually build the top.

A nation that only owns the top remains dependent forever.

Stage one: software sovereignty

The first stage is the least glamorous.

It is also the most important.

The objective is simple:

Ensure Indian AI code can run on multiple hardware platforms.

This requires investment in portable software infrastructure.

Key technologies include:

• PyTorch
• Triton
• OpenXLA
• MLIR
• UCC

These names may sound obscure.

Their role is straightforward.

They separate mathematical ideas from physical hardware.

Imagine writing a document.

You do not want a document that only opens on one brand of laptop.

You want a format that works everywhere.

Portable AI software serves the same purpose.

The model becomes independent of the machine running it.

The strategic objective is clear:

If one supplier disappears, Indian research should continue.

Maybe slower.

Maybe less efficiently.

But continuously.

This stage requires something India currently lacks in sufficient quantity: compiler engineers.

Most AI discussions revolve around researchers.

Few revolve around compiler developers.

Yet compiler developers determine whether sovereignty is possible.

Without them, every future model remains dependent.

Stage two: compute sovereignty

The second stage focuses on infrastructure.

Most people think AI requires GPUs.

That is only partially true.

AI requires systems.

A GPU without networking is useless.

A GPU without power is useless.

A GPU without cooling is useless.

A GPU without scheduling software is useless.

The true asset is therefore not the chip.

The true asset is the compute ecosystem.

India already possesses several major datacenter operators.

The challenge is coordination.

The vision should resemble a national power grid.

Not one giant facility.

A coordinated mesh of facilities.

Distributed. Redundant. Resilient.

The objective is not to create the world’ s largest cluster.

The objective is to create a cluster that survives failure.

Because resilience is ultimately more valuable than peak performance.

Stage three: model sovereignty

Only after software and infrastructure become stable should the country aggressively pursue frontier models.

This order matters.

Many nations attempt the reverse.

They begin with models.

Then discover they do not control the stack beneath them.

India should avoid this mistake.

The goal is not to create an “Indian ChatGPT.” The goal is to create models that can support:

• Governance
• Healthcare
• Education
• Science
• Industry
• Defense
• Language preservation

These models should be multilingual from inception.

India is uniquely positioned here.

Most frontier models are fundamentally English-first.

India can build systems designed from day one around linguistic diversity.

That capability will matter increasingly as AI becomes integrated into public infrastructure.

Stage four: the world model frontier

This is where the strategy becomes distinctive.

Today, nearly every major frontier laboratory is focused on text.

Text generation.

Code generation. Reasoning benchmarks. Chat interfaces.

These are valuable pursuits.

But they are also crowded.

India should ask a different question:

What if the next frontier is not language, but reality itself?

What is a world model?

A world model is an AI system that learns how the physical world behaves.

Instead of predicting the next word in a sentence, it predicts the future state of reality.

Examples include:

• Crop growth
• Flood progression
• Traffic movement
• Railway degradation
• Urban expansion
• Energy demand
• Weather patterns

The objective is understanding rather than conversation.

One promising direction is JEPA.

Understanding JEPA

JEPA stands for Joint Embedding Predictive Architecture.

The name sounds intimidating.

The core idea is surprisingly simple.

Most AI systems attempt to reproduce everything.

Every word. Every pixel. Every sound.

JEPA attempts something different.

Instead of predicting raw outputs, it predicts abstract representations.

In simple terms:

A traditional model asks:

What exact image comes next?

A JEPA asks:

What does the future situation look like conceptually?

This distinction can dramatically reduce computational waste.

More importantly, it shifts AI toward understanding structure rather than generating appearances.

India’s unique opportunity

India possesses something many frontier labs do not.

Physical diversity at continental scale.

Consider the available data:

• Satellite imagery
• Agricultural records
• Weather systems
• Railways
• Water networks
• Urban systems
• Energy infrastructure

These datasets describe reality.

Not internet discourse.

Reality.

This creates an opportunity to pursue a complementary frontier.

While others optimize text generation, India can optimize physical understanding.

Not because text is unimportant.

But because the physical world remains vastly underexplored.

The federated fractal world model vision

This is the most ambitious component of the roadmap.

Imagine one giant national model.

Now imagine replacing it with thousands of cooperating models.

Each state develops its own world model. Each district develops its own world model. Each city develops its own world model.

All communicate through a shared mathematical language.

A common latent space.

Think of it as a common coordinate system for intelligence.

Kerala understands Kerala. Rajasthan understands Rajasthan. Tamil Nadu understands Tamil Nadu.

The national system integrates insights without centralizing every piece of raw data.

This architecture mirrors India’ s federal structure.

It distributes intelligence rather than concentrating it.

It improves resilience.

It improves privacy.

It improves scalability.

And most importantly:

It aligns technology with the actual structure of the nation.

Designing against failure

Every serious sovereignty project must assume sabotage.

Not because conflict is inevitable.

But because resilience requires preparation.

The relevant question is:

What happens if something breaks?

If a hardware supplier withdraws support.

Can training continue?

If a cloud provider becomes unavailable.

Can deployment continue?

If networking equipment becomes restricted.

Can infrastructure continue?

If open-source projects disappear.

Can development continue?

A sovereign system must answer “yes” to all of these questions.

Perhaps with reduced performance.

But without existential failure.

That is the difference between resilience and dependency.

Beyond technology

Ultimately, this discussion is not about GPUs.

It is not about compilers.

It is not about neural networks.

It is about agency.

Every technological system contains assumptions about the world.

When those systems are imported wholesale, their assumptions are imported as well.

A model trained primarily on Silicon Valley data reflects Silicon Valley priorities.

A model trained on Indian agricultural systems reflects Indian realities.

Neither is inherently superior.

But sovereignty requires the ability to choose.

The ability to define one’ s own problems. The ability to construct one’ s own solutions. The ability to understand one’ s own reality. That is what AI sovereignty means.

Not isolation.

Not technological autarky.

Simply the ability to continue learning, building, and reasoning without requiring permission – as per our national interest.

Conclusion: the first line of sovereign AI

The future of AI will not be determined solely by who builds the largest model.

It will be determined by who owns the deepest layers of the stack.

The model is visible.

The infrastructure beneath it is invisible.

Yet history repeatedly shows that invisible foundations matter more than visible achievements.

India does not need to win the race to the largest chatbot.

India does not need to replicate every strategy pursued by American or Chinese laboratories.

India needs something more durable.

A software stack it understands.

A compute infrastructure it controls.

Models aligned with its needs.

And eventually, world models capable of understanding the physical systems upon which society depends.

The first line of sovereign AI is not a trillion-parameter model.

It is the decision to own the stack beneath it.

The rest follows from there.