Natural-language labels drift across languages, prompts, applications, and time. Text alone can be hard to compare, route, audit, or reuse consistently.
Why use Embedded Semantics?
Turn important language into a shared, inspectable reference.
Give people, local models, agents, and software one stable, inspectable reference for reviewed meaning without making any model or language expression the source of truth.
A resolved expression can carry its exact ConceptCode, registryVersion, original wording, and public definition across system boundaries; unsupported meaning remains explicitly unresolved.
Embedded Semantics provides governed semantic identity, not open-ended classification, permission, or a replacement for the original human expression.
Practical benefits
Why stable semantic identity is useful.
The value appears when meaning must survive a handoff: between people, languages, agents, applications, records, or time. Embedded Semantics keeps the original wording visible while adding a governed identity only when reviewed evidence supports it.
A shared reference across humans and software
Different applications and agents can point to the same published ConceptCode instead of relying on locally invented labels.
Boundary: The code is usable only after an explicit resolved response.Meaning that survives language changes
Reviewed expressions in multiple languages can attach to one stable identity while each original expression remains available for display and evidence.
Boundary: The production resolver covers reviewed exact evidence; it does not promise unseen-paraphrase resolution.Safer automation through explicit uncertainty
Unknown and ambiguous results remain first-class outcomes, allowing an agent to ask for context or continue without assigning a false identity.
Boundary: An abstention must never be converted into a best-effort ConceptCode.Inspectable definitions and provenance
Humans and machines can inspect the public Concept record, reviewed expressions, registry version, and provenance instead of trusting an opaque model label.
Boundary: The registry record is semantic authority; model evidence remains evidence only.Durable references across model upgrades
A stable ConceptCode can remain useful when prompts, local models, embedding profiles, or interface language change.
Boundary: Clients must preserve the exact code and registryVersion rather than reconstructing either.Fit check
Use it where a stable identity changes what happens next.
Will another person, agent, service, memory, event, or audit process benefit from a stable governed identity for this expression?
Good fit
- Meaning crosses a language, application, agent, storage, or organizational boundary.
- A durable memory, event, API record, or workflow needs a stable semantic key.
- The workflow benefits from explicit unknown and ambiguous outcomes instead of forced classification.
- A human or auditor may need to inspect the definition and registry evidence later.
Not the right tool
- The task is ordinary conversation, writing, translation, or summarization with no stable identity requirement.
- The caller wants a fuzzy topic label, search rank, sentiment, or unconstrained model classification.
- The caller is deciding whether an action is permitted; authorization remains a separate policy.
- The caller cannot preserve abstention and intends to guess after an unknown or ambiguous result.
Use cases
Place resolution at a meaningful boundary—not everywhere.
Each pattern below names the problem, the benefit, the best placement, the workflow, and the safety boundary. A resolved ConceptCode adds semantic metadata; it never replaces the original text, domain data, or authorization policy.
01
Multilingual agent memory
For desktop_agent · local_llm · knowledge_application
Problem
The same remembered idea may be expressed differently across sessions and languages.
Benefit
Store the original wording beside a resolved ConceptCode and registryVersion so later systems can refer to the same reviewed meaning without erasing the user's language.
Best placement
At the durable-memory write boundary, not on every conversational turn.
Show the safe workflow and success signals
Workflow
- Keep the user's original expression in local context.
- Resolve only the bounded phrase that needs durable identity.
- On resolved, store original expression, exact ConceptCode, and registryVersion together.
- On abstained, store the original expression as unresolved and assign no code.
Success signals
- Fewer duplicate memory categories caused by wording or language differences.
- Every stored code remains traceable to a public definition and registry version.
- Unknown expressions remain visible rather than silently misclassified.
Safety boundary: The ConceptCode organizes meaning; it does not authorize memory sharing or downstream actions.
02
Agent and workflow routing
For desktop_agent · automation_builder · tool_runtime
Problem
Routing rules based only on free-text labels can drift or disagree between tools.
Benefit
A governed ConceptCode can become a stable semantic input to a separately authorized routing policy.
Best placement
Immediately before a semantic routing decision whose policy already recognizes published codes.
Show the safe workflow and success signals
Workflow
- Resolve the user-approved expression.
- Use only an explicit resolved code as semantic input.
- Run the independent authorization and side-effect policy.
- On unknown or ambiguity, ask for context or choose a non-semantic fallback path without inventing a code.
Success signals
- Routing rules refer to stable codes instead of duplicated labels.
- Ambiguous intent causes clarification rather than an incorrect tool selection.
- Authorization logs remain separate from semantic-resolution evidence.
Safety boundary: A resolved identity may inform routing but never grants permission to execute a tool.
03
API, event, and record interoperability
For application_developer · api_designer · data_engineer
Problem
Independent systems often use incompatible names for the same idea.
Benefit
Attach an exact ConceptCode and registryVersion to a record or event so recipients can inspect the same definition while retaining their own display language.
Best placement
At an API, event, or persistence boundary where semantic metadata is part of the contract.
Show the safe workflow and success signals
Workflow
- Resolve before emitting the shared record.
- Carry the original expression, exact code, and registryVersion as distinct fields.
- Let recipients dereference the published Concept record when needed.
- Represent abstention explicitly instead of omitting or fabricating semantic metadata.
Success signals
- Fewer one-off mapping tables between services.
- Consumers can audit the same definition and provenance.
- Version-aware caches can be refreshed deterministically.
Safety boundary: Do not replace domain data or access-control fields with a ConceptCode.
04
Human clarification and safer assistance
For support_agent · desktop_agent · human_operator
Problem
An agent may sound confident even when a phrase is unsupported or context-dependent.
Benefit
The resolver's unknown and ambiguous outcomes give the interface a principled reason to preserve uncertainty, ask a targeted question, or continue without semantic identity.
Best placement
At a decision point where choosing the wrong meaning would materially change the next step.
Show the safe workflow and success signals
Workflow
- Submit the exact phrase and optional known language tag.
- Explain the observed semantic outcome in plain language.
- For ambiguity, ask only for the missing distinguishing context.
- For unknown, preserve the wording and continue without a code when the workflow allows it.
Success signals
- Fewer silent semantic assumptions.
- Clarifying questions are tied to an explicit ambiguity result.
- Users can see why no code was assigned.
Safety boundary: Do not frame abstention as a defect the local model should override.
05
Audit, provenance, and explainability
For auditor · system_operator · governance_team
Problem
A model-generated label can be difficult to reproduce or defend later.
Benefit
A resolved record points to a published definition, reviewed expressions, provenance, and registry version that can be inspected independently of the calling model.
Best placement
At evidence capture, logging, or review boundaries where semantic decisions must be reproducible.
Show the safe workflow and success signals
Workflow
- Record the original expression and complete resolver envelope.
- Store the exact code and registryVersion only for resolved outcomes.
- Retain the abstention reason when no assignment occurred.
- Link audit views to the public Concept record rather than a local paraphrase of it.
Success signals
- Semantic decisions can be traced to reviewed public evidence.
- Cached records state which registry version they used.
- Reviews distinguish semantic identity from subsequent authorization decisions.
Safety boundary: Provenance supports review; it does not prove that a downstream action was authorized or correct.
Adoption path
Start with one boundary. Prove the benefit. Then expand.
-
1
Discover
Understand current authority, readiness, value, and limits.
Action: Read capabilities, adoption guide, interaction guide, and live status.
Proof: The client can state when it should call the resolver and when it must not.
-
2
Try
Observe resolved, unknown, ambiguous, and error handling.
Action: Use the human walkthrough or safe local requests against reviewed examples.
Proof: The client accepts identity only from resolved plus a non-empty ConceptCode.
-
3
Integrate one boundary
Place resolution where stable identity has a clear downstream consumer.
Action: Choose one memory, event, API, routing, or audit boundary rather than resolving every utterance.
Proof: The stored or transmitted record keeps original expression, code, registryVersion, and outcome separate.
-
4
Handle uncertainty
Make abstention useful rather than hiding it.
Action: Define clarification, unresolved-storage, and no-code paths for unknown and ambiguous outcomes.
Proof: No test or production path converts abstention into a guessed assignment.
-
5
Measure
Verify that semantic identity reduces mismatch without encouraging over-resolution.
Action: Track downstream mismatch, clarification quality, auditability, and wrong-assignment prevention.
Proof: Success is measured by safer consistency, not resolution rate alone.
Best practices
Get the benefit without creating semantic noise.
The best integration is selective, inspectable, version-aware, and designed around abstention before it is enabled.
Resolve at durable handoff, persistence, routing, integration, or audit boundaries—not every utterance.
Selective placement reduces noise, unnecessary data transfer, and accidental over-interpretation.
Keep the original expression beside any resolved code.
Humans need their wording, and reviewers need to see what evidence was actually submitted.
Cache ConceptCode and registryVersion together and recheck status after deployment or bundle changes.
Version-aware records remain inspectable and refreshable without rewriting identity.
Design explicit unknown, ambiguity, and error paths before enabling the integration.
The main safety benefit disappears if the client guesses whenever the resolver declines to assign identity.
Evaluate permission and side effects after semantic resolution in a separate policy layer.
Knowing what an expression means does not establish who may act or what action is allowed.
Send only the bounded expression and optional known language tag.
The resolver does not need credentials, hidden prompts, whole conversations, or unrelated private context.
Measure value
Optimize for safer consistency—not maximum resolution.
Measure whether governed identity reduces semantic mismatch and improves inspectability while preserving correct abstention; do not optimize for maximum resolution rate.
Important: Do not optimize for resolution rate alone. A higher resolution rate is not automatically better; wrong accepted identity is more harmful than an explicit unknown or ambiguous result.
Wrong-assignment prevention
Whether unsupported or ambiguous expressions remain unassigned instead of receiving a false code.
Cross-system semantic consistency
Whether participating systems use the same exact code and definition for the same reviewed meaning.
Clarification effectiveness
Whether ambiguity leads to useful context gathering rather than silent selection.
Provenance completeness
Whether stored semantic decisions retain original expression, exact code, registryVersion, and outcome evidence.
Duplicate-category reduction
Whether stable codes reduce duplicate labels and one-off mappings across languages or applications.
Current boundary
Useful because it is explicit about what it cannot claim.
The value patterns below describe the intended use of governed identity. Actual positive resolution depends on the deployed reviewed registry; unseen expressions may correctly abstain.
- The current production resolver is reviewed-exact registry first.
- Unseen expressions may correctly return unknown_expression.
- Candidates, embeddings, similarity, confidence, and local-model output are not semantic authority.
- A ConceptCode is not permission, approval, or authorization to perform an action.
- Desktop and local agents are API clients; they do not need to host the site or run a separate model service.
See the contract in action.
Choose one durable boundary, copy its resolved and no-assignment branches, and measure safer consistency before expanding.