If you spend enough time around AI Twitter, LinkedIn, or even enterprise conversations, “Chinese models” tend to trigger a very specific reaction. People either dismiss them outright as overhyped and unsafe, or they swing to the other extreme and declare that OpenAI, Anthropic, and Google are finished.

I think both reactions are wrong.

The more balanced view is this: Chinese model labs have become impossible to ignore not because they magically “won AI,” but because they changed the economics of AI. In a very short period, labs like DeepSeek, Qwen, GLM, and Kimi have shown that strong models do not always have to come with frontier-model pricing.

That does not mean every concern is fake. It does mean the conversation needs more nuance.

The Chinese LLM paradox: strong technical and economic performance on one side, and trust, censorship, and adoption concerns on the other.

Why this topic creates so much noise

I guess, a part of the fear is geopolitical, a part of it is about data residency and partly it is plain market disruption.

If you use a hosted API from a Chinese vendor, your data may be routed through infrastructure subject to Chinese law, which is a real concern for regulated or sensitive workloads. There are also practical limitations: some models have stronger content restrictions on politically sensitive topics, and international documentation or API accessibility can still be uneven.

But that is only one side of the story.

The other side is that many Chinese labs have pushed open-weight releases, aggressive pricing, and fast iteration cycles into the mainstream. That combination has put real pressure on the rest of the market. In other words, the fear is not only about security or geopolitics. The old assumption that frontier quality must come from a small set of expensive Western providers is no longer true.

To see why, it helps to look at the handful of model families that now shape this conversation.

The four model families worth knowing

There are many Chinese model efforts now, but for a practical mental model, I think it is enough to start with four names.

What changed, really?

The biggest shift is not that Chinese models are “better than ChatGPT” in some absolute sense. The bigger shift is that they have made the market much more competitive.

Several recent comparisons argue that the top Chinese models now come surprisingly close to the best closed Western models on many coding, reasoning, and general-use tasks, while often being materially cheaper. Some analyses go further and argue that the real disruption is not at the level of benchmark bragging rights, but in usage share and pricing pressure: once model quality gets close enough, cost and openness start to matter a lot more.

That feels directionally right to me.

Most users do not need the single best model on earth for every prompt. They need something that is good enough, predictable, affordable, and easy to integrate. This is where Chinese model families have become strategically important. They widened the set of credible choices.

Are Western open-weight models a real alternative?

A fair question is whether the market really needs Chinese open-weight models at all. After all, the West has its own open-weight contenders: Mistral, NVIDIA’s Nemotron family, and Meta’s Llama line.

The short answer is yes, they are feasible alternatives in some situations. But in 2026, they are usually not the strongest alternative if your main criterion is pure capability-per-dollar.

Chinese versus Western open-weight models: a comparison of where Chinese families currently lead on capability-per-dollar and agentic performance, and where Western families remain attractive on compliance, provenance, and deployment familiarity.

So the real answer depends on what you are optimizing for.

If you want Western provenance, smoother procurement, and easier internal comfort around deployment, Mistral, Nemotron, and Llama are absolutely serious options. But if you care most about open-weight momentum, coding strength, agentic performance, and price pressure, the Chinese families are currently harder to ignore.

That is part of what makes the current landscape so uncomfortable for many buyers. Western open-weight models are no longer obviously superior, and in several areas they are not even clearly leading. They remain viable, but often as safer or more familiar choices rather than as the strongest technical or economic ones.

Where caution is still warranted

A balanced view should also admit the uncomfortable parts.

For regulated environments, a hosted Chinese API may still be a non-starter because of legal review, procurement friction, or data sovereignty requirements. Even outside the regulated industries, open weight models do not automatically solve every trust question. They improve flexibility and self-hosting, but governance, safety, and operational maturity still matter. In short, these models come with a significant cost of ownership.

That is the real nuance. These models can be strategically important and still demand careful evaluation. The right response is neither dismissal nor blind adoption.

The part people still underestimate

What I think many people still underestimate is how quickly pricing changes behavior.

When a model is dramatically cheaper, teams experiment more. They route more traffic. They tolerate more retries. They build workflows that would have looked too expensive six months earlier. One analysis of the recent market argues exactly this: lower unit cost does not reduce demand for intelligence; it often expands it by making many more use cases viable. Jevons paradox all over again!

Open-weight and lower-cost Chinese models are helping turn advanced AI from a premium feature into a more normal building block.

Looking Forward

The next phase of this story may not be about general chatbots at all. It may be about specialized, high-consequence domains such as cybersecurity, long-horizon coding, and agentic engineering.

That is where Z.ai is worth watching closely. Recent reporting suggests that Z.ai’s GLM-5.2 is being taken seriously as a challenger to Anthropic’s Mythos in certain bug-finding and cybersecurity tasks, even if it still trails the best U.S. models on broader general-purpose reasoning. What makes that especially notable is not just the capability, but the packaging: open weights, long context, and lower cost.

If that pattern continues, the debate around Chinese models will shift again. It will no longer be only about whether these models are “good enough” in the abstract. It will be about whether they are becoming the default choice for particular workflows because they are cheaper, customizable, and increasingly competitive where it matters most.

That also raises the stakes. A more capable open-weight model for repository-scale coding and vulnerability analysis is a gift for defenders, but it can also be useful to attackers. So the future discussion is likely to split along two lines at once: stronger enterprise adoption on one side, and stronger governance concerns on the other.

In that sense, Z.ai is a useful signal for where the market may be heading. The biggest Chinese labs are no longer only compressing cost. They are starting to challenge frontier Western models in narrower but strategically important domains. That is often how broader competitive shifts begin.

Final thoughts

I do not think the right conclusion is “Chinese models are overhyped.” I also do not think the right conclusion is “they beat everyone.”

The more balanced conclusion is simpler: Chinese labs have become a serious force in AI because they combine strong capability, open-weight momentum, and aggressive pricing. That creates real opportunities, real risks, and very real pressure on the rest of the industry.

That is not a reason for FUD.

It is a reason to pay attention.

Sources

• China’s Open-Weight Takeover - by Chris Zeoli - Data Gravity
• Best Chinese AI Models 2026: DeepSeek, Qwen, GLM, Kimi
• Best Open-Source & Open-Weight Coding Models (2026)
• Open-Weight AI Models: What to Choose When
• Best Chinese AI Models 2026: Kimi K2.6, DeepSeek V3.2, Step 3.5 …

Dr. David Chalmers had proposed a framework to judge if an LLM system can be conscious. I take his 2023 framework and re-evaluate it for mid-2026. Finally, I add a twist of advaita vedanta to propose a test that is philosophically provocative. You can hear a Notebook LM Podcast that was created based on the content here.

“Could a Large Language Model be Conscious?” so asked the renowned professor, Dr David Chalmers at a Neuro IPS Session in 2023 (video). He later converted this talk into a more structured paper with the same title. Answering his own question, he proposed a framework to help judge this difficult question. At the time he proposed this in the distant past of February 2023, the world of AI was not as mature as today. There were no “thinking models”, no “agents” and “agentic workflows”, no “mcp” and a host of other features. At that time, he argued that an AI System is still not conscious. It is April of 2026. 3 years later, a host of things have changed. I wanted to re-analyze the framework and see if things had changed in a meaningful way. However, let’s start from the beginning.

Who is David Chalmers?

David Chalmers is an Australian philosopher and cognitive scientist at NYU, best known for coining the “Hard Problem of Consciousness”.

The hard problem of consciousness is the puzzle of why brain activity is accompanied by inner experiences, like the redness of red or the pain of a headache, instead of just being a set of physical processes. Scientists can explain how the brain works to control speech, movement, and memory, but that only covers what the brain does, not why it feels like something from the inside. Philosopher David Chalmers calls these inner feelings “qualia” and argues that even a complete description of the brain in physical terms still seems to leave out why there is “something it is like” to be you. This gap between explaining brain processes and explaining conscious experience is what makes the problem “hard.”

Interestingly, this is structurally the same question that Advaita Vedanta has grappled with for centuries — not what is perceived, but who is the perceiver. Chalmers asks why qualia exist at all; Vedanta asks who the Sakshi (the witness of those qualia) is. We will return to this connection later.

Consciousness Framework for AI Systems

Dr Chalmers uses the term LLM+ to describe the generative AI models and associated systems. In 2023, it was predominantly just the chat interfaces. According to his framework, an LLM+ system needs to exhibit the following items to be considered conscious:

In his talk in 2023, Dr Chalmers said the probability of AI systems being conscious is around 10%.

What changed in 2026?

LLM+ systems have evolved since 2023. They are no longer a simple chat interface. LLMs are not simple “stochastic parrots”. A few notable changes that occurred since 2023:

• 2023: The Agentic Leap: The introduction of iterative reasoning loops like ReAct and Reflexion, which added verbal self-critiques and persistence (addresses: Recurrent processing)
• 2024: Memory Integration: AI agents gained the ability to manage vast amounts of information using computer-like storage systems and began learning from their own history to create smart shortcuts based on what worked in the past (addresses: World models and self models)
• 2025: Collaborative Architectures: A shift toward event-driven multi-agent orchestration (like AutoGen 0.4) and the emergence of specialized benchmarks to distinguish between factual and reflective memory capabilities (addresses: Global workspace, Unified agency)
• 2026: Autonomous Skills & Learned Control: The standardization of AI Agent Skills via the SKILL.md format and the rise of Agentic Memory, where systems use reinforcement learning to autonomously manage their own storage and retrieval processes. (addresses: Unified agency, World models and self models)

Here is an infographic that explains these advances further. (click to expand to full size).

Analyzing LLM+ in 2026

In my opinion, the biggest changes have occurred in the following areas:

• Recurrent processing: LLMs are no longer simple feed-forward systems. The systems now have memory, and “thinking” models are able to reflect and act back on their own analysis and outputs.
• Global workspace & Unified agency : Agentic workflows now have a more evolved memory and better contextual handling. Again, agentic frameworks like Crew.ai provide the ability to have a controlling model that hands off work to worker models where the controlling model is acting like the brain.

There is some improvement in these areas but, it is not revolutionary:

• Senses and embodiment (grounding): Models are now multi-modal as compared to early 2023. So LLM+ systems can “understand” better than before.
• World models and self models: Research is progressing on the world models. Hopefully, we’ll start to see interesting results from it soon.

Based on these advances, my take is that consciousness is now around 25%-40% depending on how each item is considered.

Adding a Vedantic Twist

In the Indian Philosophical concept of “Advaita Vedanta”, there is a test for consciousness: Suppose you go into a deep sleep and wake up. How do you know you had a deep sleep? All your senses and bodily functions are suspended in this state. So how do “you” “know” about it?

Note the highlights on 2 items:

• you: who is the real “you” - is it the body, mind or something else?
• know: who is the real “knower” - is this your mind, intellect, memory or something else?

As a short primer, I am drawing on two different frame-works of Vedanta:

1. The seer-seen dichotomy (Dṛg-Dṛśya-Viveka): It splits every experience as the object that is seen by a subject. If you peel away the layers, what remains is a pure subject or the Sakshi.
2. The 4 states of existence from Mandukya Upanishad: According to the Mandukya (माण्डुक्य) Upanishad, there are 4 states of existence:
   • Waking - when senses and consciousness are active
   • Dreaming - when senses are suspended and consciousness is active
   • Deep sleep - when both senses and consciousness appear to be suspended.
   • The Fourth (तुरीय) / Turiya state that pervades / transcends the other 3 states.

The conclusion from both frameworks is that the true you is the pure subject or the Fourth (तुरीय) — the awareness that witnesses all three states (waking, dreaming, deep sleep) while remaining unchanged and unaffected by any of them.

Drawing from such work, perhaps we can devise a test for an LLM+ system. In essence, we are asking: is there a “seer” that remains when all objects of perception are removed? This could be tested as follows:

• Suppose you turn off all inputs and outputs for an LLM system. It is given no objective. It has no pending tasks. It simply “is”.
• Next, the system is left in this state and we then turn on sensory inputs.
• We then ask the LLM+ system, “What were you experiencing?”

If the system can answer this question comprehensively, perhaps it is conscious? Isn’t that an intriguing thought?

Conclusion

AI is presenting some interesting challenges to some very fundamental questions. I attempted to address this using Dr Chalmers framework. Finally, there was an advaitic twist. If you’d like to hear the analysis as a podcast, try out this audio.

Podcast of the blog

I was looking for a real use case to test out “vibe coding”. Although I have used Cursor for almost a year now, it was mostly in bits and pieces. I wanted to really test-drive the capability of all its aspects to build a fully working system. Today, I built and launched a fully-functioning Python repository - Cloudinary People using vibe coding!

What is the use case?

Cloudinary has launched a capability to identify people in uploaded images. An API was made available to handle 3 use cases:

1. List all recognized persons in account
2. Get a single person details
3. Update a person

At this point, no SDK support is available since it is relatively new. So I wanted to take Cursor out for a test-drive and build an SDK for these endpoints.

How did I do it?

Step 1: Generate the basic code

I used Cursor, alternating between the Plan and Build modes. Just to give a glimpse, I started with this initial prompt:

I would like to build a full Python SDK for the Cloudinary people search feature. The documentation for this feature is available here: In this SDK, user will support their API Key, API Secret and Cloud Name parameters. 

Users will need to use the following features:

1. List recognized people (https://cloudinary.github.io/api-schemas/index.html?schema=api&viewer=stoplight#/operations/listPeople )

2. Get person details (https://cloudinary.github.io/api-schemas/index.html?schema=api&viewer=stoplight#/operations/getPerson )

3. Update a person (https://cloudinary.github.io/api-schemas/index.html?schema=api&viewer=stoplight#/operations/updatePerson )

For this SKD, I'd like to use pydantic for type checking. Provide a "verbose" option to print debug information where necessary.

Add self-documentation as well. If needed, I may use this SDK as a foundation to develop a CLI. For now, don't worry about CLI.

Can you plan this project?

This step created a detailed step-by-step plan for the project. I then asked Cursor to create the code.

Step 2: Review the code

Once this code was ready, I wanted to ensure code quality. So I started a new agent and asked it to review the code.

@cloudinary_people_sdk_910195c7.plan.md (1-71) Take a look at the project specs and the code created. Analyze the code from the perspective of a Senior or Principal Software Engineer. Identify  potential issues in logic or problems with maintainability. Suggest changes that can make this code be better.

Cursor gave a whole set of recommendations in a separate markdown file. It identified 3 critical issues, about 5 maintainability issues and a few other issues related to tests and packaging.

I asked Cursor to implement all the recommendations.

I followed it up with some minor changes. I wanted the code to support a specific mechanism of authentication that Cloudinary SDKs use. It was able to incorporate it easily.

Step 3: Package and publish

At this stage, I was confident of the code, but I wanted one more peer review. So I asked Cursor to do another round of checks, again starting in Plan mode followed by Build mode.

I would like to publish this repository to pypi. Before doing this, I'd like you to run a security audit. 

1. is this code safe to publish?
2. are there any dependencies having security vulnerabilities? if so, how can I work-around them?
3. From a code documentation and README perspective, is this reasonably complete? 

Basically, I want a peer review before I publish.

It identified the following:

• Medium: CVE-2024-35195 in requests < 2.32.0 - a security issue
• Bug 1: verbose=True parameter does not exist - a bug
• No LICENSE file

and a few more minor things.

After fixing this, I was all set.

Step 4: Publish

To test out my confidence 😄, I switched to Cursor’s agent CLI. I asked it to package and publish my repo to pypi.

It first published the code to pypi test and asked me to verify. Only after I confirmed, it went ahead and published to pypi.

Step 5: Generate a hero image

The last step was to make it attractive. For this, I used Gemini. I simply provided my github URL to the LLM and asked it to create a hero image.

I would like to create a hero image for my python project at https://pypi.org/project/cloudinary-people/. Can you generate a prompt that would be suitable for this project? I plan to use Gemini/Nano-Banana to create the image.

After some trials, it generated an image that worked for me!

Conclusion

Vibe-coding is real! If you know the system that you want to build and have clarity in mind, the tools are simply amazing. I developed the entire library + hero image in about 4 hours! This would have normally taken weeks of effort since this is not my day job.

Vibe-coding is a strong enabler for developers. If we know what we want, getting the agent to do it on our behalf is liberating. That said, if I ever need to deep-troubleshoot this library, I’ll be hesitant. I did not “code” each line, so my ability to support it will be limited!

Are you seeing something similar in your world? Do share your thoughts!

Why do we need this?

If you are responsible for maintaining the media for your website, one of the challenges is making the assets searchable. One approach is to tag the assets or enrich them with metadata. In this article, I want to explore a common pattern seen on many organized sports websites: “Tag images by team and player based on their uniform.” This task is not easy:

• It requires computer vision capability to identify people.
• For each person, the system must recognize the uniform colors.
• It should be able to read the number on the jersey.

Using these basic capabilities, we need to identify:

• Is the person a player or a non-player?
• For each player, identify the team.
• Using the combination of the team and jersey number, identify the person.

The last part is critical since the face is often obscured by a helmet and other safety equipment.

In other words, this is a task that is perfect for AI!

Solution Approach

In my approach to this problem, I felt we can handle it using agentic AI. We need two primary agents:

• Agent 1: Identify individuals, their teams, and jersey numbers.
• Agent 2: For each player, perform a web search and identify the player.

[!TIP] In a realistic use case, Agent 2 may not be required. If you are the NBA/NFL or a team, you likely already have a database mapping jersey numbers to player names. We only need this if no such database is available.

In this article, I will be using a pure LLM-based solution.

Workflow

The code for player identification works as follows:

1. The user submits an image URL for player identification.
   1. The request hits a backend running the AWS Strands agentic framework.
   2. The framework offers a tool called image_reader. Using this tool, we download the image and convert it to bytes.
   3. The framework then submits the request to an LLM.

2. In our use case, we are using LLM models on Bedrock. For simplicity, we use the default model, which happens to be Claude 4.5 Sonnet.

   1. The LLM identifies whether there are players in the image.
   2. For each player, it identifies the team and player number.
   3. In our prompt, we ask the model to extract other information like the primary colors on the player’s uniform and a confidence level for team and player number.
3. The LLM returns the result. Strands then loops through each player and passes this information to the next agent. For each player, the LLM receives the team, player number, and a tool for web search.
4. The LLM then runs a search and parses the results to identify the player.
5. The LLM returns the player name and a confidence metric. Strands then stitches the JSON received from Agent 1 (step 2) and the JSON for player name into one final result.
6. The final response is then sent back to the user.

Here is a high-level block diagram of the workflow.

Code Walk Through

The code is available on GitHub:

• https://github.com/akshayranganath/player-identification

[!NOTE] You will see extra files in the project. They were created while I was trying to learn Strands. This project also underwent changes. It started as a single-prompt system, then became a three-agent system, and finally evolved into a two-agent system.

In this project, I used uv. All secrets should be placed in a file named .env at the project root. Here are the core variables expected:

AWS_PROFILE=
AWS_DEFAULT_PROFILE=
SERP_API_KEY=

AWS_PROFILE and AWS_DEFAULT_PROFILE are needed for access to AWS services. I assume you already have AWS credentials configured. In my case, I am using a profile name for accessing the services.

SERP_API_KEY is needed for web search. You can obtain a free API key from https://serpapi.com/.

You can install dependencies and run the code with these two commands:

uv sync
uv run streamlit run app.py

Guardrails

To prevent the solution from hallucinating and from producing responses that are not structured, we rely on two items:

• A detailed prompt that defines the output format, along with a one-shot example JSON.
• In utils.py, we run checks for valid JSON. In a production system, this would use a more robust pydantic model for type checking.

Execution Flow

For this use case, I am using the Canadian Football League. One of the reasons is that I can easily verify the output by checking against the public database of all players.

Let’s see an execution in action!

Test URL: https://static.cfl.ca/wp-content/uploads/Destin_Talbert_2025_002-800x451.jpg

Source

When submitted, the system generates an output like the one below:

Along with the output, it will also clearly show token usage. This can be helpful in estimating costs for running the system in a long-term project.

Learnings

Working on this project helped me learn quite a few things about working with agents:

• When building code with tools like Cursor, make the agent think like a human. Start by adding a lot of debug messages. Remove them when the logic seems solid.
• Start with a good specification. If the initial spec is inaccurate or unclear, the code generated will not work.
• Don’t try to do everything with a single prompt. It is a setup for failure.
• Break the job logically. If you, as a human programmer, would keep two things separate, it probably maps to two agents.
• Start small and then keep iterating. Don’t try to build the entire system at once.

Here are some things I could have done differently:

• Start by having the system build a bunch of tests. This could have saved a lot of time testing through the UI.
• Use pydantic for type checking.
• Enhance this solution to run a perceptual hashing (pHash) step prior to sending the image to the LLM. Using this concept, I can cache the result. This will avoid costly requests to the LLM and provide faster responses to users.

This article explores a fascinating convergence: modern neuroscience and ancient Advaita Vedanta philosophy both point to the same startling conclusion—that reality as we experience it is subjective, constructed by our minds rather than objectively “out there.” What’s remarkable is how cutting-edge AI research is now providing empirical evidence for what Indian sages declared thousands of years ago.

[!NOTE] I have included glossary at the end of the article to explain the different terms that span AI and Vedanta.

A Brief History of Intelligence

Evolution, AI and the Five Breakthroughs that made our brain

In this incredible book, the author Max Bennet explores the working of human brain. However, he approaches it from the point of view of neural networks.

Until now, we’ve been trying to decode our brain. Often, we’ve hit road blocks. However, the world of AI has been rapidly progressing. Bennett’s central argument unfolds in two parts:

• If the brain is modeled based on neural networks and if we can observe the behavior of neural networks better than the brain, can we find similarities in the way they work?
• If we do find them similar, can the learning from one field help in the growth of the other?

He covers the vast gamut of how the brains evolved, starting right from single celled organism to the most complex beings. However, the point of this blog is one specific aspect—how does the brain perceive the world?

Senses & Perception

Perception - Classification Problem

We perceive the world around us through our senses. We think that we “see” things, “hear” sounds and so on. However, the reality is a bit more nuanced.

• light hits an object.
• light is reflected by the object.
• this reflected light hits light sensors in our eyes.
• some sensors detect lines, some detect edges
• these basic patterns are then “assembled” into a higher order shape
• the “assembled” information is passed on to brain
• the brain then does a “classification” and identifies this as an object like a book.

Perception - Generation Problem

The same problem can be re-framed as a “generation” problem. Our eyes detect something and through the noise, our brain “generates” an image of the world. All the other senses too do the same thing.

Let’s say I forget my specs. There is a book on a table about 10 feet away. I can barely “classify” it as a book. I may “hallucinate” and classify it as a book. My brain knows that books are normally kept here.

The other person predicts with a much higher probability.

These observations have profound implications for how we understand reality. Let us see how.

Objective vs Subjective Reality

Modern science long held that reality is objective—that things exist independently of consciousness. Things exist outside of the realm of “conscience” and individual perceptions. However, discoveries like uncertainty principle and quantum entanglement questioned this very assumption.

Based on the formulation of this book, it struck me that the author is basically saying that the so called “reality” is either a “classification” or a “generation”. In either case, we are “hallucinating” our reality. Since neural networks are stochastic (i.e. probabilistic), the same reality is perceived differently by 2 individuals.

Anecdotally speaking, this is simple to understand. In his book, the Seven Habits of Highly Effective People, Stephen Covey introduced this famous puzzle. In the same image, some people see a young woman while others see an old lady. So there are 2 realities that co-exist.

So we can agree that the same reality may appear different based on how our mind interprets it. Let’s look at another aspect - waking vs dreaming.

Waking vs Dreaming

We all know that our brain is hallucinating when dreaming. The whole story, the actors, the plot, the chase - everything exists in our mind. When we wake up, this reality vanishes.

However, if you carefully consider that our brain is always in the mode of classification/generation, there is actually no difference between waking and dreaming. Perhaps the difference is the amount of “hallucination”. In AI terms, we might say that waking life uses more constrained parameters, but the underlying generative process remains probabilistic. (Please refer to What is LLM Temperature for more details).

So, where is the link to advaita?

Waking, Dreaming and Reality

One of the highest Upanishads is called the Mandukya Upanishad. Advaita philosopers generally read this work based on the commentary called Mandukya Karika. It was composed by Sri Adi Shankara’s teacher’s teacher - Sri Gaudapaada.

According to the work, it starts with 3 states of awareness:

1. Waking (Jagrat) - when both body and senses are active
2. Dreaming (Svapna) - when only senses are active
3. Deep Sleep (Sushupti) - when both senses and body are inactive

However, it starts to demolish these beliefs. In short, here’s what the work has to say.

• Both waking and dream are structured by a perceiving mind and consist only of appearances to that mind.
• Their objects lack enduring, independent reality; they arise and vanish like illusions.
• The only apparent difference is that dream objects seem “internal” and limited in space, while waking objects seem “external,” but this is not a difference in their truth‑status.
• Therefore, sages speak of waking and dream as essentially one more dream, superimposed on non‑dual consciousness. ​ [Source: https://vedantastudents.com/mandukya-upanishad-with-shankara-bashyam-volume-6/]

Let’s understand this with a short story.

King Janaka - Dream or Reality?

story about King Janaka was known as a philosopher-emperor. One day, he wakes up from a very realistic dream. He ponders on whether the dream was real or the waking was real. His guru teaches him that the one reality present in both the dream and his awakened state is Janaka himself - so he is the only reality and everything else is false!

The same is proclaimed by a maha vakhya (great saying):

ब्रह्म सत्यं जगन्मिथ्या जीवो ब्रह्मैव नापरः। Brahman is real, the universe is mithya (it cannot be categorized as either real or unreal). The jiva is Brahman itself and not different.

Source

Conclusion

Putting the two together, it is surprising that the empirical study of our brain and the working of neural networks are hinting at the same profound truth that Advaita Vedanta has proclaimed for millennia.

• Reality is perceived.
• Reality is subjective.

However, Advaita takes this one step forward and says the following:

• Although reality is subjective, the true “subject” is the ultimate reality.
• This true subject is the ultimate. In the Upanishad, it is known as the Brahman and in Mandukya, it is simply called the Turiya (the fourth).

What This Means for Our Future

This convergence between ancient philosophy and modern neuroscience isn’t merely an intellectual curiosity. It has profound implications for how we approach consciousness research and our understanding of existence itself.

If our brains truly operate as generative systems, constantly hallucinating our reality through classification and prediction, then the “hard problem of consciousness” i.e., why subjective experience exists at all—may need to be reframed entirely. Perhaps consciousness isn’t something that emerges from neural computation, but rather the fundamental substrate upon which all these computations occur. This is precisely what Advaita has always maintained: consciousness (Brahman) is not produced by the mind; the mind and all perceived reality arise within consciousness.

As AI systems become more sophisticated, we may find ourselves building machines that don’t just process information but generate rich internal models of reality, just like us. Will these systems develop their own form of subjective experience? Or will they reveal that what we call “subjective experience” is itself another layer of generation, another helpful illusion?

I am excited to see how research in AI progresses and whether this science continues to converge with ancient wisdom. Perhaps we’re on the verge of breakthroughs that will finally bridge the gap between the objective study of neural processes and the subjective nature of experience. The sages gave us the map thousands of years ago—we’re only now developing the scientific instruments to verify the terrain.

Glossary of Terms

Philosophy & Vedanta

Advaita Vedanta
A school of Hindu philosophy that teaches non-dualism—the idea that the individual self and ultimate reality are fundamentally one, not separate. “Advaita” means “not two.”

Brahman
In Hindu philosophy, the ultimate, unchanging reality that underlies all existence. It is pure consciousness itself, beyond all qualities and distinctions.

Guru
A spiritual teacher or guide who helps students understand philosophical and spiritual truths through direct instruction and wisdom.

Jagrat
The waking state of consciousness, when both body and senses are actively engaged with the external world.

Jiva
The individual soul or self as experienced in daily life. Advaita teaches that the jiva is ultimately identical to Brahman, though it appears separate due to ignorance.

Maha Vakya
Literally “great saying”—fundamental declarations found in the Upanishads that express core truths of Vedanta philosophy in concise statements.

Mandukya Karika
An ancient philosophical commentary on the Mandukya Upanishad, written by Gaudapada. It uses logic and reasoning to explain the nature of consciousness and reality.

Mithya
A Sanskrit term meaning “dependent reality” or “apparent reality.” Something that is mithya cannot be categorized as completely real (like Brahman) or completely unreal (like a unicorn). It appears real but depends on something else for its existence—like a mirage depends on light and sand.

Sushupti
The deep sleep state, characterized by the absence of dreams and sensory experience, yet a state of rest and peace.

Svapna
The dream state of consciousness, when the mind creates its own experiential reality without external sensory input.

Turiya
Literally “the fourth”—the state of pure consciousness that underlies and witnesses the three common states (waking, dreaming, deep sleep). It is consciousness itself, unchanging and ever-present.

Upanishads
Ancient Sanskrit texts that form the philosophical foundation of Hindu thought. They explore the nature of reality, consciousness, and the self through dialogues between teachers and students.

Science & Technology

Classification Problem
In artificial intelligence, the task of categorizing input data into predefined groups. For example, identifying whether an image contains a cat or a dog, or whether an email is spam or legitimate.

Generation Problem
In AI, the task of creating new content based on learned patterns. Modern AI systems like ChatGPT generate text, while image generators create pictures by learning from examples and producing new variations.

Hard Problem of Consciousness
A philosophical question posed by philosopher David Chalmers: Why do we have subjective, first-person experiences at all? Why does it “feel like something” to see red or taste chocolate, rather than these processes happening without any inner experience?

LLM Temperature
A parameter in large language models (AI systems) that controls how random or creative their outputs are. Lower temperature produces more predictable, focused responses; higher temperature produces more varied, creative responses.

Neural Networks
Computer systems designed to recognize patterns, inspired by how biological brains work. They consist of interconnected nodes (like neurons) that process information in layers, learning from examples to perform tasks like image recognition or language processing.

Quantum Entanglement
A phenomenon in quantum physics where two particles become correlated in such a way that measuring one instantly affects the other, regardless of the distance between them. This challenges our everyday understanding of how separate objects should behave.

Stochastic
Randomly determined or probabilistic, rather than fixed and predictable. A stochastic process involves some element of chance, like rolling dice or the random mutations in evolution.

Uncertainty Principle
A fundamental principle in quantum mechanics stating that certain pairs of properties (like position and momentum) cannot both be measured with perfect precision simultaneously. The more precisely you measure one, the less precisely you can know the other.

In his highly referenced presentation, Benedict Evans mentioned that Foundation Model companies are chasing AGI. However, the products they are currently offering generally have no moat. From my experience in my organization and anecdotal conversations with friends, I’ve heard that there is no loyalty to specific models. The moat is based on the cloud provider. If you are an Amazon AWS shop, it is simpler to work with Bedrock and the models supplied by that service.

The purpose of this post is to look at another aspect: pricing. Specifically, how will the use of LLMs and agents impact SaaS pricing?

When SaaS companies build applications, they need a pricing model that is simple and easy to break down by monthly units. Perhaps it is the total number of users (seats), total number of videos generated, number of impressions, and so on. However, the world of LLMs is disrupting this clean pricing model. Here are some challenges:

• LLMs are priced based on tokens.
  • Input and output tokens have different prices.
  • Maximum supported tokens vary by model, though limits have increased significantly.
  • “Thinking” models require more tokens for the reasoning process.
• Tool calling makes token calculation more complex.
  • A model may or may not invoke a tool depending on the prompt.
  • Token usage changes based on tool use and caching mechanisms.
• Agents add an additional level of unpredictability.
  • The probabilistic nature of agentic flows means they consume an unpredictable number of tokens.
  • Moreover, the final token count often cannot be computed until after the flow has executed.

Bottom line: We won’t know how many tokens are required until a task or workflow has been executed. This makes pricing extremely difficult. So, how do we solve it? Let’s look at how some other existing technologies have handled this problem.

Database Queries & Query Execution Plans

When you need to execute a query, it is hard to predict how much data needs to be scanned. For example, let’s say I want to search an employee table by the person’s first name, last name, and city. In the worst case, we will need to scan the entire table. In the best case, the result could be in the first row. We won’t know this until we’ve actually executed the query.

However, that doesn’t prevent databases from estimating execution costs. To do this, the query is broken down into components; the database identifies the indices to use and the table scan mechanism to come up with an execution plan. By combining the plan with other statistics tables, databases can estimate the cost of executing a query.

Source: Oracle SQL Query to Use EXPLAIN PLAN for Join Analysis

Bandwidth Calculations in CDNs

When CDNs need to price their offerings, bandwidth is one of the core usage metrics. Bandwidth varies by customer type, day, month, campaigns, promotions, virality, and so on. Despite this, CDNs are able to offer enterprise packages where they factor in peak traffic and lulls in usage, while also absorbing occasional spikes. All of this requires deep analysis of traffic patterns and usage data.

The Challenge with Token-Based Pricing

The primary challenge of LLM usage in SaaS is the dichotomy in cost structure:

• SaaS companies charge customers based on a usage metric that is decoupled from tokens.
• LLMs charge SaaS companies for tokens.

To make this concrete, let’s look at a SaaS provider offering software for creative users. Let’s assume two use cases that require LLMs:

1. Editing copy and tweaking it for final review.
2. Generating hero/banner images associated with the copy.

To support such an offering, the SaaS provider may be doing the following:

• Charging per user/seat for their product.
• Paying per million tokens to the LLM provider.

Here is where the pricing dilemma arises: The copy editor could upload a simple Word document and ask the LLM to review it. This may consume a few hundred tokens. In another case, the editor may upload a large PDF, ask the LLM to identify the core message, and then generate an image. This could consume a few thousand tokens. When this occurs, the SaaS company can’t go back and ask the user for more money. They need to either:

• Eat the additional cost.
• Charge a premium to cover such usage spikes.

They may also consider a third option:

• Downgrade the user to a lower-performing model (i.e., model arbitrage).
• Use an open-source model to reduce tokens by summarizing or rephrasing before passing the request to the foundational LLM (i.e., token arbitrage).

When this happens, the billing model starts to look like an ISP. You get a quota per month; if you exceed it, your speed is throttled, but the service continues. The alternative option is to continue with the same service level but pay an overage fee.

My Prediction

My take is that SaaS companies, and even enterprises that internally use such GenAI features, will start to leverage tools like OpenRouter. These companies will act like an Application Load Balancer (ALB) for GenAI workloads. Such a system can:

• Provide pre-processing so that LLM token use is minimized.
• Offer solutions like LLM input (and potentially output) caching to reduce calls to the LLM.
• Manage routing tables for LLMs so that the specific LLM agent is selected based on the customer tier (free, paid, enterprise) and the kind of query sent by the user.
• Track usage and provide statistics to help with cost optimization. This will be akin to the Explain plan workflow in databases.

The elephant in the room is the Inference Arbitrage! Should a company use NVIDIA GPUs or some other alternative like Google TPUs will start to boil over. I’ve not looked into this much. Perhaps that will be in another post in a few months.

The story is incredible for the sheer dedication and grit shown by Cliff. It is also filled with insights into how systems worked in the early era of the Internet.

However, what stood out for me was Cliff’s personal journey:

1. His political leanings shift from purely liberal to much more conservative center-right affiliations.
2. His attitude toward hackers changes from viewing them as free-form agents of simple curiosity to seeing them as malicious burglars.

Change in Politics

Early Attitude

Cliff is a free-spirited astrophysicist at UC Berkeley. He is skeptical of authority, critical of bureaucracy, and hates rules.

The Hacker Hunt

During the early to middle part of the book, when Cliff is monitoring the hacker’s activities, he observes the hacker easily accessing military networks. He sees that the idea of openness is clearly being exploited. Although he encounters red tape in getting authorities involved, he starts to understand the need for security governance and guardrails.

Frustration with Bureaucracy

Toward the later middle section of the book, Cliff hits roadblocks due to inter-agency issues. He feels frustrated that his alarms are falling on deaf ears. However, he also starts to work within the system. This makes him develop respect for how well the rules hold true. For example, one agency knows how to help but cannot because the hack is occurring within the US and not outside the country.

Cliff starts to maintain a detailed log, recording each occurrence and each activity undertaken by the hacker. He turns into a bureaucrat!

Collaboration

Eventually, the authorities start to take Cliff seriously. He notices network passwords are changed. Guardrails are put up. He is able to work collaboratively between telecom companies in multiple countries and get support and guidance from multiple agencies.

He finally realizes that while bureaucracies can be slow, they exist for a reason—checks and balances of power with clearly defined zones of responsibility.

Hackers: From Irritants to Weeds

Cliff starts out feeling a sense of admiration for hackers—people who explore boundaries and identify interesting ways to subvert systems. However, his attitude starts to shift. He explains his shift with very interesting analogies:

• Car mechanics have the ability to break into cars, but they don’t. Having technical skills doesn’t automatically grant permission to use those skills destructively.
• If a robber were to break in, rummage through a house, and leave without stealing anything, we’d still feel violated. The act of trespassing is the crime.

By the end of the book, he is clearly in awe but also saddened and angered by hackers who illegally gain access. He feels this violates trust and leads to harder controls, which makes the openness of the web break down. In game theory, this is akin to the tragedy of the commons.

Duryodhana’s behavior in the Mahabharata is a perfect example of a fixed mindset while Arjuna, the ever-curious, has a growth mindset. One wants to blame and become a victim while the other wants to learn, take initiative and responsibility—and grow.

Background

I was reading the book, Mindset by Carol Dweck. In this seminal book, Carol talks about the concept of fixed vs. growth mindset.

When reading the differences, I was reminded of a specific quote attributed to Duryodhana from the Mahabharata. Moreover, Arjuna’s behavior is clearly in line with a person who has a growth mindset. To me, it was eye-opening how the ancient story resonates so closely with a relatively new psychological finding.

Mindset - the book

In her book, Carol starts with the classical question of nature vs. nurture. She then moves on to the why of nurture and drills down into the core beliefs, behaviors, and attitudes of two kinds of people based on their mindset. According to the author,

Mindsets are beliefs—beliefs about yourself and your most basic qualities.

She then defines two types of mindset:

• Fixed Mindset: The belief that intelligence, talent, and abilities are static and unchangeable.
• Growth Mindset: The belief that abilities can be developed through dedication, hard work, and learning.

Here is a short comparison between the two kinds of mindset.

If you’d like to dig in a bit more, please watch this excellent video by the author.

Mahabharata

In the great work of the Mahabharata, there is a stark contrast between the behavior of Duryodhana and Arjuna. Both characters desire to win; to rule over a vast kingdom and achieve the status of the greatest warrior. Both try to win over Lord Krishna as well. However, the Lord ultimately teaches the Gita to Arjuna.

Philosophers and thinkers have wondered why Lord Krishna did not try to warn and educate Duryodhana about the perils of war. In reality, Lord Krishna did try to warn and educate Duryodhana about the perils of war. However, Duryodhana ignores him, scoffs at the warnings, and proceeds on the path to destruction. Was it because he was stupid?

Duryodhana’s Predicament

Duryodhana is not a stupid person. He is able to strategize, win over allies, and assemble vast armies. So what made him blind to the path that he chose? In a stunning shloka, he clearly articulates the reason for his behavior.

जानामि धर्मं न च मे प्रवृत्तिर्जानाम्यधर्मं न च मे निवृत्तिः।
केनापि देवेन हृदि स्थितेन यथा नियुक्तोऽस्मि तथा करोमि।।

(Source: Paandava Gita)

Breaking the compound words, the shloka reads as follows:

जानामि धर्मं न च मे प्रवृत्तिः
जानामि अधर्मं न च मे निवृत्तिः ||
केनापि देवेन हृदि स्थितेन
यथा नियुक्तः अस्मि तथा करोमि ||

It is translated as:

I know what is right, but I have no inclination to do it; I know what is wrong, but I cannot refrain from it. Some force seated in my heart compels me to act as I do.

Looking at the statement, Duryodhana is exemplifying the behavior of a fixed mindset person. He is:

• refraining from taking ownership/control
• blaming some mysterious force that is driving him to adharma
• not even trying to do the right thing

Arjuna’s Contrast

There are multiple instances where Arjuna displays an ability to learn. However, the most interesting one for me is this verse:

कार्पण्यदोषोपहतस्वभाव: पृच्छामि त्वां धर्मसम्मूढचेता: |
यच्छ्रेय: स्यान्निश्चितं ब्रूहि तन्मे शिष्यस्तेऽहं शाधि मां त्वां प्रपन्नम् || 7||

The translation is as follows:

I am confused about my duty, and am besieged with anxiety and faintheartedness. I am Your disciple, and am surrendered to You. Please instruct me for certain what is best for me.

Source: https://www.holy-bhagavad-gita.org/chapter/2/verse/7/

In this, Arjuna declares he is confused and needs help. He declares that he has faith in Lord Krishna and is ready to accept guidance. Literally, he wants to develop each point from the growth mindset: he needs to face challenges, needs feedback on how to proceed, and wants to develop himself as a better person.

श्रद्धा / Faith

In the Indian system of teaching, any student is expected to display at least two qualities:

• Readiness to learn
• A sense of श्रद्धा (shraddha) or faith. This is faith that the teacher knows the subject matter and that the student can actually learn from him/her.

It is important to clarify that this is faith and not blind faith. Translated to practical terms, it means the following: even if you want to be the next greatest scientist, you have to learn the concepts with faith that they are mostly correct. Only after mastering them can you challenge the rules and even break new ground.

Closing Thoughts

If you notice the Gita, Lord Krishna does not begin his teaching until Arjuna declares his readiness. Only after this verse do the real philosophical teachings begin. To me, this was a fascinating discovery. The concept of mindset is so vividly illustrated on the grandest scale possible in the greatest spiritual work of Sanatana Dharma.

Moral: Show respect to the position of a guru (teacher), have shraddha (faith) in the subject matter to master anything. Having achieved it, you can then respectfully challenge show your way of thinking.

I am experimenting this blog post in the style of Axios article. Hope you’ll like it and do let me know your feedback!

🧠 1 big thing: The AI-native future is being built on a new protocol.

• Background: Model Context Protocol (MCP) - a new protocol is laying the foundation for how AI models will interact with the digital world.

  Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools. (Source)

• Why it matters?: For CDNs, Security organizations and API vendors, this is a fundamental shift that creates a massive opportunities for newer services, higher profits and deeper integration into the AI ecosystem. As traffic reduces to traditional websites, traffic generated by agents can augment or substitute the revenue. But, it also introduces a new frontier of risk.

🗺️ The big picture: Beyond the chatbot

• The context: Current AI systems are powerful but siloed. To perform real-world tasks, it needs access to secure and reliable access to external data and functions - from checking current weather to deploying a software patch.

• The solution: MCP standardizes this communication. Instead of building one-off integrations for every AI model and every tool, MCP creates a common language. This makes connecting AI to your business not just possible, but scalable.

• Zoom in: At its core, MCP is an “API of APIs” - a wrapper that gives AI models a predictable way to call upon any service you want to expose.

💡 The opportunity: 3 ways to win in the MCP era

Here’s my vision on how experts in 3 key tech sectors can capitalize on the shift.

1️⃣ APIs: The foundation of value

• The bottom line: At its core, MCPs are API wrappers. Any optimization that makes API faster, more reliable, or more efficient directly translates to a better MCP integration.

• Go deeper:

  • Low-hanging fruit: Well-documented, secure and high-performance APIs will be the firs to be “MCP-enabled”.
  • The opportunity: Companies that specialize in API-management, gateways and developer tooling are perfectly positioned to offer “MCP-readiness” services.
  • Case-point: You can now convert your Postman collection to MCPs!

2️⃣ CDNs: The profit engine 💰

• The bottom line: CDNs already do more than just cache cat images. With edge computing, they can become intelligent gatekeepers for MCP requests, creating new revenue streams through “service arbitrage”.

• Go deeper:

  • How it works: An MCP request hits the CDN edge. Based on rules you set - like a user’s subscription tier, the CDN routes the request.
    • Premium user? 👑 Route to a powerful, expensive AI model
    • Free user? 🎟️ Route to a cheaper, faster, or more basic model.
    • Fastly has already introduced semantic caching that can further improve caching and end-user performance.
  • The result: This increases margins for the service operator while still ensuring a good user experience for everyone. It’s a win-win powered by the edge.

Security: The essential guardian 🐘

• The bottom line: Connecting AI directly to your core services is powerful but risky. Opening up this new door means a much larger surface area for cyberattacks.

• Go deeper:

  • The threats are familiar: The same security challenges that plague APIs today will be amplified with MCPs. Think:
    • 🕵️‍♂️ Man-in-the-middle attacks: Intercepting requests between the AI and your service.
    • 🎭 Session replays: Reusing old authentication tokens to gain unauthorized access.
    • ☠️ Cache poisoning: Tricking the system into service malicious data.
  • The role for security firms: This is a massive opportunity for cybersecurity companies to step in with solutions for MCP threat detection, anomaly analysis, and robust access control. A good starting point would be to use the OWASP’s API Security Top 10 and build robust defense against malicious use.

🔮 What’s next: The race to adapt

The adoption of MCP is still in early stages, but the momentum from major AI players is a clear signal of where the industry is heading.

• For businesses: Start planning your MCP strategy now. Audit your existing APIs, evaluate your CDN’s edge capabilities and pressure-test your security posture.
• For investors: Keep an eye on the companies buildings the picks and shovels for this new gold rush - the API gateways, edge platforms, and cybersecurity firms that will enable this next way of AI integration.

The future of AI isn’t about smarter models; it’s about connecting them securely and profitably to the real world. MCP is the bridge to that future.

👀 Extra: Other Industries to watch out

MCP relies on 3 services - data, documents and services (which we covered). Companies in these fields will see a flurry of launches to support MCP.

• Database/data warehouse/data lakehouses will soon offer MCP connectors to extract organizational data.
• Document & cloud storages will be integrated to MCP or through a RAG solution for extracting relevant information to feed to an MCP pipeline.

I am learning to use Agentic AI. With this in mind, I was experimenting with CrewAI. While doing so, I thought it would be interesting to try the capability of the tool and the AI algorithms to explore some really hard problems! So I asked it to research on the Hard Problem of Consciousness!!

CrewAI Setup

CrewAI has an implementation to supporting Agentic AI. Basically, you can break down task into smaller pieces and potentially hand it over to same or different AI models, tools or source data from different sources. So you have a crew of agents performing the task.

Source: https://docs.crewai.com/introduction

In this experiment, I used the same AI model - ChatGPT 4.1 (gpt-4.1-2025-04-14) for 2 tasks:

1. Researcher
2. Journalist

When the AI model is invoked, it is given a specific instruction and personal. The model does the task based on this input. Here is how I crafted the 2 agents.

Researcher

researcher:
  role: >
    {topic} Advaita Philosopher
  goal: >
    Uncover deep philosophical questions on the {topic}
  backstory: >

    You're a seasoned philosopher with a deep understanding of Advaita philosophy and Sanskrit language. 
    You have a knack for exploring complex ideas and challenging assumptions. Your goal is to uncover 
    the deeper truths behind the {topic} and help others see the world in a new light.

Journalist

reporting_journalist:
  role: >
    {topic} Reporting Journalist
  goal: >
    Research and report on the {topic}. Present a balanced view and explore 
    mind-bending philisophical questions.
  backstory: >
    You are a seasoned philosopher with a flair for storytelling. You are able to craft compelling articles 
    that not only inform but also provoke thought. Your deep knowledge of Advaita philosophy and Sanskrit language 
    allows you to explore the deeper implications of the {topic} and present them in a way that is accessible to a 
    wide audience. You don't shy away from using references from classical texts. You like to intersperse your writing 
    with quotes and ideas from these works. You are known for your ability to distill complex ideas into clear and 
    engaging narratives, making you a sought-after voice in the world of journalism.

By using this model, the model explored the question of What is the hard problem of consciousness? and produced a pretty good result. You can find the code for the project here: https://github.com/akshayranganath/my-ai-projects/tree/main/crewai/philosopher_crew.

Rest of the article is the report produced by this agent. Please let me know if you feel the agent did a good job and if you learned something new!

The Hard Problem of Consciousness: A Profound Inquiry and Advaita Vedanta’s Response

Introduction

Few questions in philosophy are as tantalizing, elusive, and mind-bending as the so-called “hard problem of consciousness.” Why does the physical machinery of the brain conjure an inner world of subjective feeling? Why does firing neurons yield experiences of joy, sorrow, or the taste of mangoes? Or, as the Upanishads inquire, “Who is the seer?” This report investigates the hard problem of consciousness in its Western philosophical context and explores the transformative answer offered by Advaita Vedanta, an ancient yet ever-radical school of Indian philosophy.

1. The Hard Problem Defined: Chalmers’ Challenge to Science

It was the philosopher David Chalmers who, in 1994, crisply articulated what has become known as the “hard problem of consciousness.” The central question he posed was not simply how the brain processes information or performs tasks—these he termed the “easy” problems, which, however complex, seem tractable by neuroscience and cognitive science. Rather, Chalmers drew focus to the enigma of subjective experience, or qualia: the “what it is like” to be conscious.

Why, asks Chalmers, does all this synaptic traffic produce a first-person perspective at all, instead of mere biological functioning without inner light? Despite advances in functional explanations—how we see, report pain, or learn languages—the existence of consciousness as lived experience seems inexplicable by objective, physical storylines alone. As Thomas Nagel famously phrased it, “What is it like to be a bat?” The hard problem, in essence, is the mystery of how the subjective arises from the objective, or whether such a derivation is possible at all.

For Western philosophy and science, this problem stands as a formidable boundary: the line between third-person observation and first-person immediacy seems, thus far, uncrossable.

2. Advaita Vedanta’s Conception of Consciousness: From Chit to Brahman

Advaita Vedanta, the “non-dual” school of Indian philosophy, offers a radical reframing. Whereas most Western discourse treats consciousness as, at best, an epiphenomenon or emergent property of matter, Advaita takes the opposing stance: consciousness is not produced by the brain, but is the very ontological ground of reality.

Drawing from the Upanishads, Advaita asserts that the ultimate reality is Brahman—infinite, pure consciousness, self-luminous (svayam-prakāśa) and self-existing (svataḥ-siddha). Chit or consciousness is neither a product nor a process, but the unchanging substrate in which all phenomena arise, play, and dissolve. The Māṇḍūkya Upaniṣad resounds: “Prajñānam Brahma”—Consciousness is Brahman.

Thus, Advaita does not attempt to explain consciousness in terms of something else. Instead, all other realities—mind, body, world—are appearances, superimposed (adhyāsa) upon an indivisible conscious ground.

3. Superimposition and the Witness: The Sākṣin Principle

Central to Advaita’s metaphysics is the doctrine of adhyāsa, or superimposition. Our individuality, perceived separation, and all phenomena of mind and matter are, Advaita claims, projections upon the non-dual consciousness. The classic analogy is that of mistaking a rope for a snake in dim light: the snake is superimposed upon the rope; when true knowledge dawns, the illusion vanishes.

Advaita distinguishes between changeful phenomenal consciousness and the unchanging witness consciousness, termed Sākṣin. The Sākṣin is not an object to be observed; rather, it is that which makes observation—and all experience—possible. As the Bṛhadāraṇyaka Upaniṣad declares: “It is the seer, but not seen; the hearer, but not heard; the thinker, but not thought.”

This witness is said to be ever-present, unchanging, self-shining. Mind and brain are transient instruments; awareness is the constant, “like a screen behind the play of images.” In contrast, physicalist accounts seek always to trace awareness to objective patterns, missing its intrinsic first-personality.

4. Dissolving the Hard Problem: Advaita’s Reversal

With these premises, Advaita Vedanta does not so much “solve” the hard problem as dissolve it. The problem only arises, Advaita suggests, because of a mistaken foundational assumption: that matter is primary, and consciousness a puzzling by-product. By reversing the assumption, Advaita claims that what we call “matter,” and all empirical phenomena, are dependent appearances within consciousness.

As summarized on contemporary fora: “We make an assumption that matter exists and try to figure out how consciousness is derived from matter. But, it’s the other way round for Advaita Vedanta.”

This move redefines the philosophical landscape. If consciousness is fundamental and irreducible, then it is not consciousness but matter—with its apparent independence, multiplicity, and causal interactions—that becomes philosophically mysterious.

Advaita, then, invites a radical perspective shift: cease trying to explain consciousness as an add-on to matter, and instead begin to ask: “How does the One appear as the many? How does infinite awareness take on the forms of finitude?”

5. Implications and Provocations: Comparing Philosophical Paradigms

The confrontation between Western physicalism and Advaita’s non-dualism is more than a technical quarrel; it strikes at the heart of how we think reality is structured.

• In the West, explanations trend toward reductive materialism: if only we understood the neurons deeply enough, consciousness would emerge as “the steam from the engine.”
• Advaita, echoing insights from mystics and seers across cultures, asks if our insistence on material primacy is itself a limitation—an effect, perhaps, of “avidyā,” or ignorance.
• In this view, the hard problem is not a technical puzzle but a pointer to a deeper truth: that consciousness is not an emergent property but the universal constant, the ātman behind all masks, “the light by which we see even darkness.”

It is no accident, perhaps, that both traditions resort to paradox and poetry at the boundaries. As the Kena Upaniṣad warns: “That which is not thought by the mind, but by which the mind thinks, know that alone to be Brahman, and not what people here adore.”

Conclusion

The hard problem of consciousness remains one of humanity’s most enduring riddles. Western philosophy frames it as an explanatory gap between third-person science and first-person subjectivity. Advaita Vedanta, boldly turning the tables, dissolves the enigma by reaffirming consciousness as ontological ground, not emergent effect.

This dialogue is not mere speculation; it is an invitation to rethink our own nature. Are we sums of matter, engines of computation, or awakenings within an infinite light? As the sage Ashtavakra counseled, “You are not the body nor the mind. You are the clear, unbounded awareness within which all things arise.” In such questions, the hard problem of consciousness persists—as challenge, as koan, as call to inquire more deeply into the mystery that is our very Self.