The question that decides an AI selection is not which capability looks best in a demonstration. It is whether the capability is something you own or something you are renting, because that answer determines what happens to your product in three years — and to your listing, which is the part buyers actually have to sign.
So the conclusion, in the order we would put it in a sourcing note.
Ask who operates the capability before you ask what it does. If a third party runs the model, you are dependent on a contract you do not hold. If the supplier runs it, you are dependent on a supplier relationship. If the model runs on the device, you are dependent on your own firmware maintenance. All three are workable. What is not workable is a listing that promises a capability without knowing which of the three you have.
Write the degraded state down before you write the feature list. What does the product do on day one when the service is unavailable? If the answer is "the feature disappears and the rest of the product still works", the feature can be sold. If the answer is "the product looks broken", the feature cannot be sold without a fallback you have to pay for.
Put a notice obligation in the agreement. Not the feature itself — a feature cannot be guaranteed to a fixed specification in this category — but the notice period before it is withdrawn, changed or re-priced. A notice period is the only commercially realistic protection available, and its absence is what turns a routine supplier change into a delisting.
Do not expect our documentation to answer the dependency question. We publish an AI voice assistant capability across the camera platforms and describe AI translation support on the independent site. We publish no processing location, no architecture detail, no language coverage, no accuracy, no latency, no subscription terms, no app operator and no data jurisdiction, for any model. That is the honest state of it, and the specific question to put to us is the one below.
Smart glasses AI features: dependency before capability
Ask a supplier about accuracy, language coverage or latency first, and you will get an answer that sounds like progress and is not. All three are properties of a deployed system operating in your conditions, on your firmware, in your market, with your network. None of them can be settled in advance from documentation, and all three are settled by testing a sample. The dependency question, by contrast, can be settled in advance — and it determines what the other three are worth.
There are three arrangements, and each one has a different failure mode.
The model runs on the device. You control the capability and you maintain it. What you own is the firmware, the memory budget, the thermal behaviour and the engineering effort to keep the model current. This is the arrangement with the most durable capability and the most engineering attached to it, and the one a brand with an embedded engineering team can usually justify.
The supplier runs the model. You are dependent on a commercial relationship rather than on an external contract. The technical answer exists, because the supplier owns the implementation, and asking for it is a normal supplier question rather than an unusual one. The question to ask is still the same one: what happens to this feature if we stop working together, and what happens in the six months after we do.
A third party runs the model. This is common in the category and it is frequently the better commercial choice — the capability arrives without an embedded engineering programme. What it means is that you hold a customer-facing promise and a contract with somebody you have no direct relationship with, and the two can come apart.
The buyer who does not know which of the three applies is in the most common starting position in this category, and that is the first thing to establish — before the capability appears in any listing, quotation or specification.
Two related rows deserve to be asked at the same time rather than later. Where the inference happens determines the offline story and the privacy story, and it follows directly from the dependency answer rather than being an independent question. And whether a firmware update can remove the feature is a separate question from who operates it: a supplier-hosted capability can be withdrawn by a supplier decision, a device-side capability can be withdrawn by a firmware update, and the second one is the one most brand-side buyers forget because it feels like their own engineering choice.

What our documentation says about AI, and what it leaves open
On this, short and it is a limit rather than a position we have chosen to hide. We reference an AI voice assistant capability across the camera platforms. We describe AI translation support on the independent site, and the K01 carries an AI translation description in the catalogue that is a self-described capability rather than a measured one. Those are the AI statements our published material makes.
Everything below is open, for every model in the range:
- Processing location — on device, on a supplier server, or on a third party's infrastructure.
- The architecture: model family, size, quantisation, and whether the capability is a general assistant or a fixed set of commands.
- Language coverage, in both directions, and what happens to a language that is not covered.
- Accuracy, latency and time-to-first-response.
- Subscription terms, price change path, and what happens when a customer stops paying.
- The app operator, and whether the operator is the same legal entity as the manufacturer.
- Data jurisdiction, retention period and whether any processing is used for model improvement.
- The update mechanism, and whether a feature can be removed by an update.
That list is not a complaint about our documentation. It is the list a corporate procurement questionnaire asks for, and in this category the answer to most of those questions does not exist at the platform level at all — it exists as a contract term. Which is the point: for AI capabilities, the specification and the contract are the same document. A buyer who expects a datasheet to settle this will be waiting for a document that will not arrive.
One practical consequence deserves emphasis for private-label programmes specifically. A capability that is described in the catalogue but is operated by a third party has a chain of dependencies that is longer than the product's own bill of materials: the assembly factory, the firmware integrator, the model provider, the app operator and whoever holds the accounts. A supply chain audit that stops at the factory has not audited the product's behaviour. In an enterprise channel, that is where the security questionnaire fails, and in a consumer channel, that is where the support ticket arrives.
A second point concerns the difference between a described capability and a measured one, because in this category they are used interchangeably and they are not the same thing. A catalogue line that names a capability — a voice assistant, translation — establishes that something exists on the device. It establishes nothing about the language pair, the accuracy, the latency, or what happens when the network is poor. The commercial risk of collapsing the two is specific: the listing inherits the capability name, the customer inherits the expectation of a general-purpose feature, and the unit inherits the behaviour of a fixed command set. Three outcomes are possible — the customer is delighted, the customer is indifferent, or the customer returns the product as not delivering what the page promised — and only one of them is under anybody's control.
The practical countermeasure is to describe capabilities at the level they were demonstrated, and to say what the demonstration was. "Recognises the commands listed in the quick start guide" is defensible. "Understands natural language" is a different and much larger promise, and in this category it is the kind of promise that survives a demonstration and fails in a review. Where a capability is described in the supplier material, ask whether the description was validated on a production unit or written for a brochure, and treat the two differently in your own copy.

The contract rows that decide whether a feature survives a supplier change
The rows below are the ones to ask for, and the pass lines are what a usable answer looks like. The right-hand column is the useful one, because it separates a supplier who owns the capability from one who is relaying somebody else's documentation.
| Row to request | Pass line | What a soft answer sounds like |
|---|---|---|
| Operator of the model | A named legal entity, and who contracts with it | Provided by our partner |
| Processing location | Device, supplier server or third party, named | Cloud based |
| Offline behaviour | Which functions remain with no network | Works without internet |
| Language and mode coverage | An enumerated list, with the fallback language | Supports multiple languages |
| Subscription and price change path | The terms, the notice period and the price history | Free to use |
| Update mechanism | A described path from a shipped unit to a new build | Updated through the app |
| Data jurisdiction and retention | The jurisdiction, the period and the improvement-use position | Secure by design |
| Notice before a feature is withdrawn | A period in writing, and who gives it | Features may change |
The commercial question behind this table is the one most buyers raise last, which is the wrong order. If the capability carries a subscription, then the customer lifetime cost includes a component you do not control, and the price change path is a margin risk that arrives without notice. A brand that has built a listing around a free capability and then discovers a per-month charge behind it has two problems: the margin, and the listing copy. Both are easier to fix before the artwork than after.
The second commercial question is the support cost of a degraded state. If a feature disappears, the customer contacts you, not the model provider. The cost of that contact lands in your service organisation, and it lands there whether the feature was designed to be dependable or not. A degraded state that is defined — the product keeps its other functions, the user sees a clear message rather than a silent failure — is a support line item. A degraded state that is undefined is a support cost with no ceiling, and it is also the reason that the fallback has to be priced into the programme rather than assumed.
The clauses we would expect to see in the purchase order or the framework agreement:
- The shipped feature set identified by firmware version, attached to the order as a line item.
- A notice period before a capability is withdrawn, re-scoped or re-priced.
- The degraded state described in writing, with the functions that remain.
- The subscription terms and the price change path, where a subscription exists.
- A change-control notice obligation covering the model provider, the app operator and the firmware baseline.
- The data jurisdiction, the retention period and the position on using customer data for model improvement.
- An acceptance criterion in the sample protocol that the shipped unit matches the described feature set.
That last one is the one that does the most work. It is simple to write, it costs nothing, and it converts an argument about a capability into a question about a firmware version.

Testing a capability you cannot get in writing
Because accuracy, latency and offline behaviour cannot be resolved in advance, they can be resolved directly, and the protocol is short enough to run in a day. The value of the exercise is that it produces a number that is specific to your product and your customers, which is worth more than any published benchmark and considerably more than a demonstration.
Build the request set before you test. Fifty sentences that resemble what your customer will actually say, including proper nouns, numbers, dates, and deliberately ambiguous phrases that a real customer produces without noticing. Run the same fifty through every candidate unit, including any competitor sample you buy for reference. Record the failures, not the successes — a success rate without the failures tells you nothing about where the boundary is.
Test with the network off. If your customers will use this in places with poor connectivity, that is the operating condition rather than an edge case. What you are looking for is the degraded state, and it should be observed on the unit that ships rather than described by the supplier.
Test the failure mode. Feed it input it should refuse — a request it cannot fulfil, a question with no safe answer, a claim it should not make — and see whether it flags uncertainty or returns a confident answer. This is the test with the highest commercial value per minute spent, because a confident wrong answer in an AI feature is the one that generates a customer complaint rather than a feature request.
Test the update path. Ask for a unit on the current firmware and a unit on the previous firmware, if the supplier can provide both, and confirm that the capability is present on both. A capability that arrived in an update is a capability your installed base does not have, and that gap is a support and a review problem rather than a technical one.
Write every observation down before you discuss it. A supplier disputing a written observation is arguing with evidence. A supplier who has never seen the test is arguing from theory, and the first conversation is far more productive than the second.
Where an AI programme breaks, and what we can tell you today
Five failure patterns, written as symptom, root cause and prevention, because in this category the failures are commercial rather than technical.
The feature disappears in a firmware update and the listing is still live. The symptom is a review score that drops in one week, or a retailer's own test finding the unit does not do what the page says. The root cause is that the listing names a capability rather than a firmware version. The prevention is the version line item on the purchase order, plus the notice obligation.
A language or a market is dropped. The symptom is that the capability works in the development market and not in the market the product actually ships into. The root cause is that language coverage was never contracted, only demonstrated. The prevention is the enumerated list in the request table, with the fallback behaviour stated.
A capability is operated by a party the buyer's own procurement team has not assessed. The symptom is a security questionnaire that stalls in a customer's procurement cycle, weeks after the order. The root cause is that the supply chain audit stopped at the factory. The prevention is to ask for the operator and the data jurisdiction before the first order, and to include them in the sub-tier list in the audit request.
A free capability turns into a paid one. The symptom is a margin complaint with no obvious cause, arriving a quarter after launch. The root cause is that the subscription terms were never requested. The prevention is the price change path clause.
The support cost of an outage is uncapped. The symptom is a service organisation carrying load for a feature that is not yours. The root cause is that the degraded state was never defined. The prevention is to write the degraded state into the specification and to run the network-off test on the sample.
Concretely, we publish the capabilities our documentation supports, and where a row is open we say so rather than filling it with a plausible value. For AI that means: the voice assistant reference across the camera platforms and the AI translation description on the independent site are available to you today; processing location, operator, language coverage, accuracy, latency, subscription terms, data jurisdiction and update mechanism are not, for any model. We will not estimate them, and we will not present a self-described capability as a measured one.
There is a practical reason for that beyond caution. In this category, the rows we cannot answer are the rows a buyer must contract for, and a buyer who has been told "not published" knows to put them in the request list. A buyer who has been given a plausible answer does not, and finds out later that the answer was ours rather than the company's.
Three things to do this week.
- Send the eight document requests as a list, with the operator named first. A supplier who answers all eight owns the capability; one who answers two is telling you where the risk sits.
- Write the fifty-sentence request set and the network-off test, and put them in the sample acceptance criteria. One page, one day, and it produces the only capability data you will ever own.
- Send us the model, the markets and the customer profile. We will tell you which of these questions we can answer for that configuration from our documentation today, which we cannot, and where the answer we would need has to come from the company in writing.
The feature background is under AI features in smart glasses, the limitations worth designing around are in ai features limitations and drawbacks, the procurement checklist is in ai features procurement checklist, and the sample route is in sample evaluation.
Related reading
- What you should not depend on — ai features limitations and drawbacks
- Establishing the rows first — ai features procurement checklist
- Testing what you cannot get in writing — sample evaluation
Ask us the dependency question for a specific model and we will tell you whether we can answer it.



