The Bluetooth device name is the one string on a smart glasses product that almost everybody touches, almost nobody owns, and almost everybody gets wrong at the point where getting it wrong becomes expensive. It is what a buyer sees in the operating system's device list after pairing, what a shop assistant reads out over the telephone, what a support agent asks the customer to spell, and what the end user reads in the Bluetooth menu on a phone they will hold for three years. It is also a string that has to be decided before the requirements gate closes, because after that gate the name is frozen into firmware, into the regulatory file, into the artwork, into the packaging, and into every carton that carries the product into a market.
This article is about that decision. It treats the Bluetooth device name as an engineering artefact rather than a marketing one, because that is what it is at the point where it matters. The question is not what sounds good on a shelf. The question is: what is the rule that produced this string, who signed it, what does it have to be consistent with, and how will anybody prove three years from now that the unit in a customer's hand is the unit that was approved?
Engineering customization: what the device name actually is
A Bluetooth device name is a human-readable label carried in the Bluetooth stack and advertised to hosts during pairing and bonding. It is a fixed-length field with a practical ceiling, so long names are either truncated by the host, silently mangled, or rejected outright depending on the phone, the headset profile and the operating system in question. That behaviour is exactly why a name cannot be treated as a free marketing surface. A name that reads perfectly on a desktop configurator can arrive truncated in the field, and a support team that has been trained on the full string will spend its first call explaining that the name they expected does not look like the name on the screen.
The device name is also not a serial number, a MAC address, a certificate identifier or a marketing name. It is not a lookup key into the supplier's build system, and it is not a reliable way to tell one production batch from another. Its entire function is recognition: it is the label that lets a human associate a radio with a physical object in a room. Everything else about how a product is identified — order codes, factory codes, certification model strings, serial numbers, box codes — lives somewhere else and behaves differently.
It helps to keep three layers separate, because most naming disputes are actually a dispute between layers that were never defined as different:
- The consumer-visible identity. The device name a user sees after pairing, together with any companion app label. This is what the end user will read out loud to a colleague, and what a retailer will use when training staff.
- The programme identifier. The internal ordering code that connects a purchase order line, a tooling record, a firmware build and a compliance document to one physical configuration. This is what the supplier uses to find the right thing six months later.
- The regulatory model string. The exact model designation that appears on the declaration of conformity, the test reports and the packaging. This is the string a market surveillance authority, a customs broker or a channel partner's compliance team will ask for.
The device name is layer one. The programme identifier and the model string are layers two and three. They may share words, and often they do, but they answer different questions and they travel through different processes. A project where one string does all three jobs usually works right up to the moment a change is needed in one of them, at which point the change propagates into the wrong artefacts.
One catalogue fact is worth pausing on here, because it demonstrates the same principle from the opposite direction. In the published catalogue, Bluetooth version is published for 14 models. It is not published for the 11 camera models, nor for A05, nor for A06, nor for the bone conduction family. The catalogue is the marketing and technical summary artefact, and its job is to tell a reader what is known about a product line. The absence of a Bluetooth version in a catalogue row is a statement about what that row reports, not a statement about what the hardware contains or what the device is named. A published catalogue row and a device name are different artefacts with different owners, different update triggers and different audiences. Any naming rule worth having has to survive that same separation: a rule that only works while a catalogue row is accurate is not a rule, it is a coincidence.
There is a fourth, quieter property of the device name that matters for channel buyers in particular. It is the string a user sees in a list of many devices, and lists are sorted alphabetically in most operating systems. A product whose name begins with a common letter will sit in the middle of a long list; a product whose name begins with the brand will sit wherever the brand sorts. In a retailer's demo unit, in a customer's paired-devices screen, and in a support ticket, that placement is the difference between a name that helps and a name that adds friction. This is a design input, not a detail, and it belongs in the requirements document alongside the functional specification.
In practice, we will treat the device name as a specified output of the engineering programme, with an owner, a rule and a verification method, rather than as a value that gets filled in later because nobody objected to the default. That stance costs one paragraph in the requirements document and saves a reprint.

Why the device name is not the model string
The model string has a legal job. The declaration of conformity is issued against an exact model string that will ship. A declaration that covers a product family rather than a model is not a declaration for your SKU, and the moment you ask a market surveillance question about a specific unit in a specific carton, the answer must be traceable to one string on one document that names one model. That is why the model string cannot be a moving target, and why a change to it re-opens the compliance file rather than merely updating a string in a build script. The wider regulatory and marking landscape is treated separately in Bluetooth SIG, certification, marking and labelling; this article stays on the naming question that sits underneath it.
The device name has no such legal job. It is a label. It can change, and in a well-run programme it will change several times over the life of a product, for entirely legitimate reasons: a market launch adds a language suffix, a channel partner requests a distinguishable string so their units can be identified at the counter, a firmware update fixes a spelling that shipped by mistake, a new generation is launched alongside the old one and needs to be tellable apart from it.
Here is the trap. If the device name is built by deriving it from the model string automatically, then any change to the model string changes the device name, and any change made for a marketing reason to the device name changes the model string. The two are welded together. In production this shows up as the classic failure: a packaging refresh or a channel-specific unit gets a different name, the firmware now reports a string that does not match the document, and the compliance file no longer describes the product. The reverse also happens — a model string variation, say adding a suffix to distinguish a regional variant, silently changes the name the customer sees.
The correct structural answer is that the device name is generated from a rule that the programme owns, and the model string is generated from a different rule, and the two rules are explicitly allowed to reference each other but never to be the same string. When you ask a supplier to describe their naming setup, the useful answer looks like: the device name follows this template, this prefix identifies the product line, this suffix identifies the configuration, this part is fixed and this part is variable, and here is what happens when the variable part changes.
The same separation has to hold against the model string printed on the box. Packaging artwork is drawn once and reprinted many times, and the artwork carries the model string and the regulatory marks that travel with it. The device name lives in firmware and can be revised by an update without touching a carton. If the two are set to be identical, every firmware change becomes a packaging question, and packaging is the most expensive thing in the chain to get wrong, because the artwork run is committed, the cartons are already in transit, and a mismatch on a market surveillance inspection is not a formatting issue.
There is a third artefact that gets confused with both of these: the product name as it appears in marketing, on a datasheet, in a channel price list, and in the quotation. That name is commercially owned by the brand, it can be aspirational, and it is often several words long, which makes it a poor candidate for a fixed-length radio label in the first place. A radio label of practical length will usually be an abbreviation, and the abbreviation is where the rule has to be written down. If the abbreviation is chosen by whoever types the firmware build rather than by the programme, you will find three variants of it in the field within two production runs, and none of them will match the compliance file.
We will require the supplier to state, in writing, the relationship between the device name and the model string, and we will require that relationship to be a mapping rather than an identity unless there is a documented reason for identity. Where identity is chosen, we will accept it only with an explicit change rule that says a firmware-side rename is a compliance event.

Deciding the naming rule before the requirements gate closes
The requirements gate is the first of six gates in the CYNRIN development framework, and it is finished when it produces a document, not when a date arrives. That document is a signed written requirement statement covering the target market, the models in scope, the configuration, the packaging, the delivery documentation, and — this is the part that matters for this article — which claims the product is allowed to make.
A naming decision belongs in that document because it is a requirement, not a detail. It costs nothing to decide at this point and it costs a great deal to decide later. By the time samples are built, a name is in firmware, on a label, in a test record and in a customer expectation. Changing it at that point is a re-verification exercise rather than an edit.
At the requirements gate, four things about naming should be settled. They are not detailed design; they are constraints, and each one exists to stop a specific late dispute.
The scope of the name. Decide whether there is one device name for the whole programme, one per model, or one per variant. Most programmes with more than one product line converge on a family prefix plus a configuration token, because it makes the whole range legible in one device list, which matters for a user who owns two of them and for a support agent who needs to tell them apart. The alternative — one fixed name per model — is simpler to explain but produces a device list full of near-identical entries, and the disambiguation then falls on the user.
The fixed and the variable parts. Write down exactly which characters are fixed for the life of the product and which may vary, and who is permitted to vary them. A common, workable pattern is a fixed brand token, a fixed product-family token and a variable configuration token, where the variable token maps one-to-one onto a documented set of values. What must not happen is the variable part being derived from something that can drift, like a build timestamp or an internal tooling number.
The relationship to the model string. State explicitly whether the device name contains the model string, references it, or is deliberately different, and if it contains it, state which portion of it. A rule that says "the device name is the model string plus a fixed suffix" is a legitimate rule; what is not legitimate is leaving the relationship undefined and letting it be decided by whoever writes the firmware build.
The change path. Decide what has to happen, and who has to agree, before the name may be altered after the requirements gate closes. A sensible rule is that any change to the device name after the compliance file is closed requires written notice and a re-check of the relationship to the model string and the packaging. This is not bureaucracy; it is the mechanism that prevents a firmware-side convenience from silently invalidating a document-side commitment.
There is one further decision, and it is commercial rather than technical: what happens to the naming effort if the programme stops. This is the same class of question that applies to tooling, and it deserves the same treatment, because tooling and the naming rule are both engineering investments that only pay off if the programme reaches volume. A supplier who owns the naming rule and the tooling should be willing to say what is recoverable if the programme is paused after the requirements gate but before the pilot run, and what is not. For a buyer, this is a negotiating position that is much stronger before the tooling is committed than after.
What should not happen at this gate is a naming rule so detailed that it functions as a firmware specification. The gate is for constraints, not implementation. A rule written as "the device name shall be the fixed brand token, the fixed product-family token, a separator, and the configuration token from the approved list" is right. A rule written as a table of hex values is not, and it will be wrong anyway because the implementation belongs to the supplier. The wider sequencing question — what belongs in a design phase and what belongs in a build phase — is covered in ODM development and the design phase, and the depth of change a platform can absorb is set out in OEM-ready platforms and customization depth. The naming rule sits inside that envelope: it is a requirement you set, not a capability you request.
The table above is the working artefact we keep in the file. In practice it is short: three columns, the audience for each layer, who owns it, what it is allowed to be derived from, and what happens when it changes. Keeping the three separate in a single sheet prevents the most common naming dispute from becoming a multi-week argument during sample review.
The flow matters because it places the naming decision in the right gate. The naming rule is settled at the requirements gate, it is implemented during the engineering and tooling stage, it is verified against the golden sample at the samples-built-and-verified gate, it is captured in the compliance file, and it is re-confirmed on the pilot run before mass production. Notice that the name is not verified by looking at the packaging. It is verified by pairing a device and reading what it reports.
How the name behaves across a range of several models
A range introduces a second question that a single product never has: how the buyer and the end user tell the units apart. The rules that work here are few and they are structural.
First, the fixed part of the name should identify the brand or product family consistently across the whole range, so that a customer who buys two different models recognises them as related rather than as two unknown devices. Second, the variable part should be short enough to be read aloud over a telephone without ambiguity, because that is how it will be used in a support call and how it will be used by a shop assistant restocking a shelf. Third, the variable part should map onto something the customer already knows — a colour, a size, a lens option, a channel tier — rather than onto something only the factory knows, because a customer who can identify their own unit from the device list will not open a ticket.
Fourth, and this is the one that is easiest to overlook, the range needs a stated uniqueness rule. If two models in the programme could ever produce the same name, then the pairing experience and the support experience both degrade, and the fix arrives as a firmware update after the units are in the channel. The uniqueness rule should be a stated constraint in the requirements document, checked against every combination of model and variant that the programme permits, including the ones that are not currently in the range but are on the roadmap.
We will build the naming rule so that it scales to the range without a redesign, and we will insist that the supplier confirm the uniqueness property for the full set of permitted combinations, not only for the configurations in the first purchase order. A pilot order tests one configuration; the naming rule has to survive all of them.
How naming is verified at the samples-built-and-verified gate
The samples-built-and-verified gate is the fourth gate in the framework, and its output is specific: a signed golden sample plus a verification record covering pairing, audio, charging, any camera function and control behaviour. The naming question has a natural home in that record, because the device name is only observable through the pairing step and the operating system's device list.
The verification is not "the name looks right". It is a repeatable check that a second person can run and get the same answer. In practice that record contains: the exact expected name string, the host environment used for the test, the number of devices visible in the host list, the result of pairing, whether the name was reported in full or truncated, and the signature of the person who ran it. When more than one host platform is in scope, the check is run on each, because truncation and display behaviour differ by platform and by operating system version, and the failure mode is precisely the one a buyer will hear about: a customer who cannot find the device they just paired.
Two verification details are worth specifying in advance.
The first is that the check compares the name against the requirement document, not against the supplier's own reference. If the requirement document says the fixed part is one token and the variable part comes from an approved list, then the test verifies that the string conforms to that rule, not that it matches whatever the supplier believes the name should be. The golden sample is the physical reference; the requirement document is the normative one. Where they disagree, the requirement document wins and the sample is wrong.
The second is that the record has to survive a later firmware update. A verification record that is valid only for the firmware build it was made against is of limited use, because the first thing a channel partner will ask after a mid-life update is whether the name still matches what their staff were trained on. Recording the firmware build identifier alongside the expected name is what turns a one-off check into something that can be re-verified after an update without rebuilding the whole sample protocol.
We will put the naming check in the verification record with the same status field as every other item, so that a failure is visible in the same place as a pairing failure or an audio failure. A naming defect that is tracked separately from the rest of the verification tends to be tracked more loosely, and loose tracking is how it reaches the channel.
The checklist is short by design. Six or seven lines, each with a pass, fail or not-applicable status, each with a named owner, and each pointing back to a line in the requirements document or the golden sample. A checklist that a buyer can read in two minutes and a support team can act on is worth more than a long protocol that nobody completes.

Questions to ask about a naming decision
These are the questions we put to a supplier during the feasibility and requirements stages, and they are the ones that reliably expose whether a naming setup is deliberate or accidental. They are written so they can be asked in a meeting and answered on the spot, and so that the answers can be pasted into the requirement document afterwards.
- What is the exact device name template, and which parts of it are fixed for the life of the product?
- Which parts are variable, what is the approved list of values, and who is permitted to authorise a new value?
- Does the device name contain the model string, reference it, or differ from it — and if it differs, how does a reader map one to the other?
- What exactly happens if the model string changes after the compliance file is closed?
- What happens to the device name if the programme stops after the requirements gate but before the pilot run, and what is recoverable at that point?
- How is the name verified at the samples-built-and-verified gate, on which host platforms, and what record is kept?
- Which catalogues, packaging artworks and documentation templates are affected by a name change, and which of them are already committed to a print run?
Three further questions belong in the commercial conversation rather than the engineering one, and they are the ones that protect the buyer in a negotiation. First: what does a name change cost in terms of firmware work, samples, re-verification and packaging, and who bears each of those costs. Second: whether the supplier can commit to a naming rule that survives a firmware update, and whether they can commit to maintaining the mapping table between device name and model string for the duration of the programme. Third: what support material the supplier will provide so that a channel partner's staff, the brand's own support team and the end user all say the same string. In a programme with a heavy channel element, that last point is where naming rules actually pay for themselves.
None of these questions require the supplier to disclose anything that is not published — no capacity figure, no indicative schedule, no price, no volume. They are all answerable from the supplier's own engineering process. A supplier that cannot answer them has a naming setup that was improvised rather than designed, and that is worth knowing before the requirements gate closes rather than after the pilot run. The range of brand and platform choices that sit upstream of this decision is set out in OEM-ready platforms and branding options.
We will also keep a written record of the answers in the programme file, and we will re-read it at every gate. A naming rule that was agreed in a meeting and never written down is a rule that two parties remember differently, and the device list in a customer's phone is the place where two different memories finally meet.
The commercial questions sit in the same file as the engineering ones. A naming decision is rarely the thing that decides whether a programme proceeds, but it is frequently the first place where a negotiation becomes concrete, because naming touches packaging, firmware, certification evidence and the training material a channel partner will use. We will keep the naming rule, the model-string mapping and the certification evidence in one place in the programme file, so that when a quotation is prepared, a purchase order is raised or a pilot order is agreed, the naming decision is visible in the same document as the commercial terms rather than buried in a firmware build note.
Several ordinary commercial facts are not published. The MOQ, the lead time, the warranty terms and the incoterms basis for a shipment are stated during the commercial conversation rather than in a public catalogue, and that is normal. The practical consequence for a naming decision is that nobody should rely on a distributor's memory of a previous programme when the naming rule changes. The name appears in the device listing, in the training material, in the spares documentation and in the support instruction, and every copy has to travel with the change.
The most useful thing to ask the supplier about naming is a standing rule rather than a one-off answer: who signs a name change, what it costs in engineering and in re-verification, and which downstream documents it touches. That is where the trade-off appears — a change made before the compliance file closes is a re-verification exercise, and a change made after it is a re-verification exercise plus a packaging question. It is also where the negotiation belongs, because the tooling cost and the engineering effort of the change are known to the supplier, while the consequence of a mismatch between a shipped model string and a declaration is known to the buyer. Neither side can price the other's exposure, which is exactly why the rule has to be written before the programme starts rather than negotiated after the first shipment.
Finally, the honest limitation: the device name is a small artefact, and no amount of process makes it the difference between a successful programme and a failed one. What it does is remove one recurring source of friction in the field, one recurring source of argument in the file, and one recurring source of mismatch between what a customer sees and what a document says. That is worth a paragraph in the requirements document. It is not worth a dispute at the compliance file, and it is certainly not worth a reprint.



