ICNLI Protocol: Why AI Needs a Standard for Operational Context, Not Just the Internet

The problem: your AI assistant knows Wikipedia, not your warehouse

Most AI assistants today are trained on the internet and deployed against your business. That gap is the whole problem. A model can tell you the history of double-entry bookkeeping but has no idea your invoice #4471 is overdue, that your warehouse in Reno is short two SKUs, or that the client you're emailing already churned last quarter. It knows the public web extremely well and knows your operational reality not at all.

The industry's answer to this has mostly been "memory." Bolt a vector database onto the model, stuff in some chat history, call it context. It helps, a little. But it's a patch on a design that was amnesiac from the start: a model with no persistent, structured, leveled understanding of what's actually going on in your systems, your calendar, your inventory, your open tickets. Memory features let the assistant remember what you said to it. They don't give it a standing, operational picture of the world it's supposed to be acting in.

That's a different problem than "the AI forgets things." It's that nobody ever specified what an AI assistant should know, at what depth, updated on what cadence, and verified by whom, before it's allowed to act. Without that specification, every vendor invents their own ad hoc version of "context," and every one of them is a guess dressed up as a feature.

ICNLI is an attempt to actually specify it.

What ICNLI actually specifies

ICNLI stands for a protocol for operational context and safe execution, not a prompt format, not a plugin API, a specification for what an AI system needs to know and how it needs to check itself before it acts. It's published at icnli.org.

The protocol defines nine levels of context, moving from the general to the specific: from broad world knowledge down through organizational structure, live operational state, and the fine-grained facts of the task at hand. The point of laying it out in levels is that most AI failures aren't failures of intelligence, they're failures of altitude, a model reasoning brilliantly at the wrong level of context, confidently answering a question it was never actually informed enough to answer.

The second core piece is the mandatory TWO-STEP Safety Protocol. This is the part that matters most and gets talked about least. A model proposes an action. It does not execute it. A separate, auditable step, the kernel, not the model, decides whether that action actually happens. This is the architectural answer to a question every AI deployment eventually has to face: who decides? Under ICNLI, the model never gets to be the last word on its own actions. It drafts. Something else checks. A hallucination can't act, because acting was never the model's job in the first place.

The third piece is proactive awareness: the system is specified to surface relevant context before you ask for it, not wait to be prompted with the right question. An assistant that has to be asked the right question to know your invoice is overdue isn't operationally aware, it's a search engine with better manners.

Three names, three jobs: ICNLI, Imperal, Webbee

It's worth being precise here, because the industry loves collapsing distinct things into one marketing noun.

• ICNLI is the open protocol. It's a specification, published at icnli.org under a Creative Commons CC BY-SA 4.0 license. Anyone can read it, implement it, build on it, fork it, as long as derivatives stay open under the same terms. ICNLI itself doesn't run anything. It's the rulebook, not the player.
• Imperal is the commercial runtime that implements ICNLI end-to-end, the AI Cloud OS that actually runs the nine levels of context, enforces the TWO-STEP Safety Protocol at the kernel, and does the operational work. If ICNLI is the spec, Imperal is a real, running implementation of it, built to production use, not a proof of concept.
• Webbee is the agent, the reference implementation you actually talk to inside Imperal. She's not a rebrand of the OS and not a chatbot skin bolted on top of it; she's the face and voice of the system, operating within the boundaries the kernel enforces. Worth saying plainly: she proposes, the kernel decides.

Keeping these three separate matters. Plenty of vendors sell you an "AI agent" that is quietly the whole stack, spec and runtime and personality fused into one undifferentiable product, which makes it impossible to know what's actually being verified versus what's just branding. ICNLI, Imperal, and Webbee are deliberately not that.

Why an open protocol matters, and why the HTTP comparison is a claim about the future, not the present

The reason ICNLI is published openly, under a share-alike license, instead of kept as Imperal's proprietary secret sauce, is the same reason HTTP wasn't kept as one browser's secret sauce: a protocol that only one vendor can implement isn't a protocol, it's a product with an API. Anyone can build against ICNLI. Anyone can audit it. Anyone can implement their own runtime against the same nine levels and the same TWO-STEP Safety Protocol Imperal implements, and there's nothing stopping them, because the spec is licensed to allow exactly that.

Here's the honest caveat, because it matters: HTTP didn't earn "nothing works without it" status the day it was published. It earned that status retroactively, over decades, through adoption most of us weren't around to argue about. ICNLI is not there. It's early. It's one open protocol with one production implementation, not an industry consensus, not an ISO standard, not an IETF RFC. Calling it a standard in the formal sense would be dishonest. What it is is an open, licensed specification that anyone is free to build toward, the same starting position HTTP was in before it became infrastructure nobody thinks about anymore. Whether ICNLI gets there is a bet on the idea, not a fact about its current adoption.

Where to go from here

If you build AI systems and you're tired of "memory" being the only answer to "my AI doesn't know what's actually happening," the protocol is worth thirty minutes of your time. Read it at icnli.org, it's open, it's licensed for reuse, and nobody's asking you to take a vendor's word for what it says.

If you want to see what a full, running implementation of it looks like, nine levels of context, the TWO-STEP Safety Protocol enforced at the kernel, an agent that surfaces what you need before you ask, try Imperal, and talk to Webbee directly. The spec tells you what should be true. The runtime is where you find out if it actually is.