NLWeb: Microsoft’s Open Protocol Letting Any Website Talk Back

Microsoft buried the lede at Build 2026. While everyone was busy dissecting Copilot demos and oohing at agent workflows, NLWeb — Microsoft’s open protocol letting any website answer natural language questions directly — quietly walked in and rearranged the furniture.

No search engine middleman. No ranking algorithm. Just your site, talking back to users in plain language.

Most coverage chased the flashy stuff. Meanwhile, this protocol slipped through with almost no fanfare — and honestly, that surprises me every time I think about it. NLWeb could reshape how websites serve information, how developers build experiences, and how SEO works at a fundamental level.

Here’s the thing: today, users ask Google a question. Google crawls your site, indexes it, and maybe — maybe — surfaces your answer. With NLWeb, users or AI agents ask your website directly. Your site responds. The middleman vanishes.

What NLWeb Actually Is and How It Works

NLWeb stands for Natural Language Web. It’s an open protocol Microsoft released under a permissive license — and specifically, it defines a standardized way for any website to accept natural language queries and return structured answers.

I’ve watched a lot of “open standards” announcements come and go over the years. This one feels different. The architecture is surprisingly straightforward, and that simplicity is a feature, not a limitation.

Here’s the technical breakdown without the jargon overload:

• Query endpoint: Your website exposes a dedicated URL that accepts natural language questions via HTTP requests
• Schema.org integration: Responses use Schema.org vocabulary, making them machine-readable and interoperable across the AI ecosystem
• Model Context Protocol (MCP) compatibility: NLWeb works alongside Anthropic’s MCP standard, so AI agents can interact with your site without friction
• LLM-powered processing: Your site uses a large language model backend to interpret queries and generate answers from your own content

A user or AI agent sends a natural language question to your NLWeb endpoint. Your server processes it against your content database using an LLM, then returns a structured, Schema.org-formatted response. That’s it.

Your data never leaves your infrastructure. You control the answers, the context, and the entire experience — and honestly, that alone sets this apart from most AI integrations I’ve seen.

Microsoft built the reference implementation using Azure AI services, but the protocol itself is cloud-agnostic. You can run it on AWS, Google Cloud, or your own servers. That openness matters enormously — and it’s not an accident.

NLWeb — Microsoft’s open protocol letting any website handle queries natively isn’t just a Microsoft product. It’s a web standard proposal. That distinction makes all the difference.

The Technical Architecture Behind NLWeb

Understanding how NLWeb — Microsoft’s open protocol letting any website responds to queries means looking at three distinct layers. Bear with me here — this is worth understanding properly.

1. The transport layer. NLWeb uses standard HTTPS. There’s no new protocol to learn, no exotic infrastructure required. If your site already serves web pages, it can serve NLWeb responses. The protocol specifies JSON-LD as the response format, which most developers already work with regularly.
2. The intelligence layer. This is where LLMs come in. Your site needs some form of language model to interpret incoming questions. Microsoft’s reference implementation uses GPT-4o, but you can swap in any model — Llama, Claude, Gemini, whatever fits your stack and your budget. Fair warning: smaller models work fine for focused domains, but you’ll notice the quality difference on complex queries.
3. The content layer. NLWeb queries run against your existing content — blog posts, product pages, documentation, FAQs. The protocol includes a retrieval-augmented generation (RAG) pattern, meaning the LLM pulls relevant content chunks before generating answers. This surprised me when I first dug into the spec. It’s elegant.

Here’s what makes this fundamentally different from adding a chatbot to your site:

Feature	Traditional Chatbot	NLWeb Protocol
Standardization	Proprietary per vendor	Open, Schema.org-based
Interoperability	Siloed to one platform	Works with any AI agent
Data control	Often cloud-dependent	Fully self-hosted option
Discovery	Manual integration needed	Auto-discoverable via manifest
Response format	Free text	Structured JSON-LD
Agent compatibility	Limited	MCP-native

The manifest file deserves special attention. Similarly to how robots.txt tells crawlers what to index, NLWeb uses a manifest file that tells AI agents what your site can answer, what topics it covers, and how to reach the query endpoint.

Consequently, AI agents can discover your NLWeb capabilities automatically. No manual registration, no API marketplace listing — just a file sitting on your server.

Furthermore, the protocol supports streaming responses. For complex queries, your site can send partial answers progressively, keeping latency low and the experience smooth. That’s not a minor detail — it’s the difference between feeling responsive and feeling broken.

How NLWeb Complements Project Solara and Microsoft’s AI Agent Ecosystem

Build 2026 wasn’t just about NLWeb. Microsoft also unveiled Project Solara, its framework for building autonomous AI agents. Nevertheless, most people haven’t connected the dots between these two announcements — and that’s the real story.

Here’s the connection. Project Solara agents need to interact with websites. Currently, they scrape pages, parse HTML, and essentially guess at meaning — a fragile process that breaks constantly. I’ve built integrations on top of this kind of scraping before, and it’s miserable maintenance work. NLWeb — Microsoft’s open protocol letting any website serve structured answers gives Solara agents a reliable, standardized interface instead.

Think of NLWeb as the “mouth” of your website. Solara agents are the “ears.” Together, they create a conversational web where AI agents and websites actually talk to each other fluently.

The ecosystem works like this:

1. A user asks a Solara agent to find the best running shoes under $150
2. The agent identifies relevant retail websites with NLWeb endpoints
3. It queries each site directly in natural language
4. Each site returns structured product recommendations from its own live inventory
5. The agent synthesizes answers and presents them to the user

No Google. No Bing. No search results page.

Moreover, this pattern extends well beyond shopping. Healthcare sites could answer symptom questions directly. Government sites could explain policy changes in plain language. University sites could guide prospective students through admissions without making them dig through twelve nested pages.

Microsoft’s Copilot platform already integrates NLWeb discovery. When Copilot encounters a website with an NLWeb manifest, it queries that site directly instead of relying on Bing’s index. That’s not a future feature — it’s live now.

Additionally, the protocol supports authentication. Enterprise sites can require OAuth tokens before answering queries, which opens NLWeb to internal tools, partner portals, and gated content — not just public websites.

The competitive angle here is hard to miss. Google’s search monopoly depends entirely on being the intermediary. NLWeb — Microsoft’s open protocol letting any website bypass that intermediary is a direct challenge to Google’s core business model. Although Google has its own AI efforts with Gemini and Search Generative Experience, NLWeb approaches the problem from a completely different direction. It doesn’t try to build a better search engine. It tries to make search engines optional.

Competitive Implications: NLWeb vs. Traditional SEO and Search

Let me be blunt about this. NLWeb — Microsoft’s open protocol letting any website handle queries directly carries massive implications for anyone working in SEO — and most of them haven’t fully registered what’s coming.

What changes:

• Keyword rankings become less relevant. If users query your site directly, position #1 on Google matters less than it used to
• Content quality becomes everything. Your NLWeb responses are only as good as your actual content — there’s no algorithm to game here
• Structured data becomes critical. Schema.org markup isn’t optional anymore; it’s the literal foundation of how NLWeb responses work
• Site authority shifts. Authority now comes from being discovered by AI agents, not from backlink profiles

What stays the same:

• You still need genuinely great content
• You still need fast, reliable infrastructure
• You still need to understand what users actually want
• You still need information organized in a way that makes sense

However, the power dynamics shift dramatically. Today, Google Search Central guidelines essentially dictate how you structure your content. Tomorrow, NLWeb-compatible sites might bypass Google entirely for specific query types. I’ve seen similar shifts before — the sites that moved early on mobile and structured data won. This feels the same.

Notably, this doesn’t mean SEO dies. Search engines will remain important for discovery. But once an AI agent knows your site supports NLWeb, it’ll prefer querying you directly over scraping search results. That’s a meaningful change in where traffic comes from.

The smart play for SEO professionals right now:

1. Start adding Schema.org markup aggressively — not someday, now
2. Build complete, authoritative content that genuinely answers real questions
3. Prepare your infrastructure for NLWeb endpoint deployment
4. Watch the protocol’s evolution through Microsoft’s GitHub repository
5. Test early with the reference implementation before your competitors do

Conversely, sites that ignore NLWeb risk becoming invisible to the next generation of AI-powered browsing. The protocol is open, the barrier to entry is genuinely low, and early adopters will hold a real advantage. The real kicker? Most of your competitors are still sleeping on this.

NLWeb — Microsoft’s open protocol letting any website respond intelligently marks a foundational shift — moving the web from “search and click” to “ask and answer.” That’s not incremental. That’s a different web.

Practical Use Cases for Developers and Enterprises

So who should actually care about NLWeb — Microsoft’s open protocol letting any website serve natural language responses? Honestly, almost everyone building for the web. But some use cases stand out immediately.

E-commerce platforms. Product discovery changes completely. Instead of browsing category pages, a shopper asks: “What’s the best waterproof jacket for hiking in the Pacific Northwest under $200?” Your NLWeb endpoint returns personalized, inventory-aware recommendations — no search engine needed. I’ve tested similar RAG-based setups on e-commerce stacks, and the conversion difference when users get direct answers is significant.

Documentation sites. Developer docs are notoriously painful to browse — anyone who’s spent 45 minutes hunting through nested sidebars knows this. NLWeb lets developers ask in plain English: “How do I authenticate with OAuth 2.0 in your Python SDK?” Your site answers directly, pulling from your actual docs.

Healthcare providers. Patients can query hospital websites about services, insurance acceptance, and appointment availability. Importantly, the healthcare provider controls every answer — cutting the risk of search engine snippets misrepresenting medical information. That’s not a minor benefit.

Government agencies. Citizens shouldn’t have to fight through confusing bureaucratic websites. With NLWeb, a question like “How do I renew my passport if it expired more than five years ago?” gets a direct, authoritative answer from USA.gov or the relevant agency. No more hoping Google surfaced the right page.

SaaS companies. Support costs drop when your website answers product questions natively. Furthermore, NLWeb responses can include structured actions — like links to start a free trial or upgrade a plan — making them genuinely useful rather than just informational.

News publishers. Media organizations can serve verified, sourced answers to current events questions. This fights misinformation by ensuring AI agents get answers directly from journalists, not from scraped summaries of unknown origin.

Implementation steps for developers:

1. Audit your content. Identify what questions your site should answer, then map your existing content to those questions honestly
2. Set up Schema.org markup. Every page needs proper structured data — use Google’s Rich Results Test to validate your work
3. Deploy the reference implementation. Microsoft’s open-source code gives you a working NLWeb endpoint in hours, not weeks
4. Connect your LLM backend. Choose a model that fits your budget and latency requirements — smaller models work fine for focused domains
5. Create your manifest file. Define your site’s capabilities, topics, and endpoint URL clearly
6. Test with AI agents. Use Copilot, Claude, or other MCP-compatible agents to verify your responses actually make sense
7. Monitor and iterate. Track which questions users ask, then improve your content based on real query patterns — not assumptions

One more thing worth noting: the protocol also supports multi-turn conversations. A user can ask a follow-up question, and your NLWeb endpoint maintains context — creating a genuinely conversational experience that static web pages simply can’t match. That’s a bigger deal than it sounds.

Additionally, enterprises can deploy NLWeb internally. Imagine querying your company’s intranet: “What’s the PTO policy for employees in California?” Your HR portal answers instantly and accurately. No ticket, no waiting, no digging through a SharePoint maze.

NLWeb — Microsoft’s open protocol letting any website become conversational isn’t theoretical anymore. The reference implementation exists today, the specification is published, and the ecosystem is actively forming.

The Bigger Picture: Why NLWeb Matters for the Future of the Web

Step back for a second.

NLWeb — Microsoft’s open protocol letting any website respond to natural language queries represents something bigger than a single protocol. It represents a real shift in how the web fundamentally works — and I don’t say that lightly after a decade of watching “paradigm shifts” turn into minor footnotes.

The web was built on links. You click from page to page, following hypertext. Search engines organized those links into ranked lists. That model has dominated for 25 years, and we’ve all just accepted it as inevitable.

NLWeb proposes something different. Websites become conversational partners — they don’t just serve pages, they answer questions. They don’t wait to be crawled, they respond on demand.

This aligns with broader industry trends. Anthropic’s Model Context Protocol standardizes how AI models connect to external tools and data sources. OpenAI’s plugin ecosystem attempted something similar. However, NLWeb is more fundamental — it operates at the web protocol level, not the application level. Consequently, any AI system that speaks HTTP can use it. No vendor lock-in, no proprietary APIs, no marketplace gatekeepers.

Nevertheless, real challenges remain — and I’d be doing you a disservice by glossing over them:

• Compute costs. Running an LLM for every query isn’t free. High-traffic sites need efficient inference infrastructure, and that math gets uncomfortable fast
• Abuse prevention. Open endpoints could attract spam queries or denial-of-service attacks. Rate limiting and authentication help, but the problem isn’t fully solved yet
• Quality control. Bad content produces bad answers. NLWeb amplifies whatever’s on your site — the good and the embarrassing
• Adoption curve. Standards only work when enough sites adopt them. NLWeb needs critical mass, and that takes time
• Privacy concerns. Query logs reveal user intent in granular detail. Sites must handle this data responsibly — and many won’t

Although these challenges are real, none are insurmountable. Similarly, early web standards like RSS and JSON-LD faced genuine skepticism before achieving widespread adoption. The pattern is familiar.

Microsoft is betting that NLWeb — Microsoft’s open protocol letting any website participate in the AI-native web will become as fundamental as HTTPS. That’s a bold bet. But given the direction AI agents and conversational interfaces are heading, it’s a reasonable one — and I’ve learned to take Microsoft seriously when they plant a flag in infrastructure.

The quiet bombshell of Build 2026 isn’t about flashy demos. It’s about plumbing.

And in technology, the plumbing always wins.

Conclusion

Bottom line: NLWeb — Microsoft’s open protocol letting any website respond to natural language queries is genuinely transformative. It removes the search engine as intermediary, gives website owners direct control over how AI agents interact with their content, and does all of this through an open standard anyone can use today.

The actionable next steps are clear:

• Developers: Clone the reference implementation from Microsoft’s GitHub. Deploy a test endpoint on your staging site this week — not next quarter
• SEO professionals: Double down on Schema.org markup and complete content. Prepare for a world where direct queries increasingly supplement traditional search
• Enterprise leaders: Evaluate NLWeb for customer-facing sites and internal knowledge bases. The ROI on reduced support costs alone justifies early investment
• Content creators: Write content that answers real questions thoroughly. NLWeb rewards depth and accuracy — keyword tricks won’t help you here

NLWeb — Microsoft’s open protocol letting any website become conversational isn’t coming someday. It’s here now. The specification is published, the tools are available, and the ecosystem is growing faster than most people realize.

The websites that adopt NLWeb early will own the conversational web. The ones that wait will wonder why their traffic quietly evaporated.

Don’t be in the second group.

FAQ