Logos Lexicon
Bounded intent tokens for policy resolution
Logos Lexicon is the advanced layer after the core approval loop and VINAC-FM proof path. The beta TypeScript SDK compiles .logos vocabularies, creates signed intent tokens, maps tool calls, and fails closed when required proof is missing.
Four Foundational Principles
Logos Lexicon is not a command language. It is a compact vocabulary of pre-agreed semantic tokens resolved locally without instruction parsing.
Bounded Intent, Not Instructions
Agents transmit compact intent references. The receiving system resolves meaning locally from a versioned logic library.
Transport-Agnostic
The same signed intent token model can ride over VINAC-FM, optical, UWB, NFC, wired local buses, or conventional network transport.
Policy Before Execution
Every token is checked against version, context, parameter bounds, nonce or session reference, authorization level, and local policy.
Local Logic Libraries
Logic libraries are pre-agreed and locally stored. No remote code execution. No prompt parsing. Meaning is deterministic and auditable.
The Semantic Coordination Stack
Logos Lexicon sits between cloud policy and local execution. The transport proves delivery or presence; Logos defines meaning.
Cloud Policy Layer
Projects, protected endpoints, policies, receipts
Logos Lexicon 2.0
Intent IDs, context bits, parameters, nonce refs
Local Logic Library
Versioned handlers and safety constraints
Transport Abstraction
VINAC-FM · Optical · UWB · NFC · Wired · Network
How It Works
From policy-bound intent to deterministic local resolution
State-Frame Token Generation
Vocabulary version, intent ID, context bits, parameter indexes, and nonce or session references become a compact state frame.
Transport Validation
VINAC-FM, NFC, QR, optical, wired, or network transport supplies delivery and proof metadata. The token itself stays transport-independent.
Local Logic Library Resolution
The receiving machine maps the token to a pre-approved handler and enforces context, parameter ranges, risk level, required authorization, and audit labels.
Logos 2.0 Seed Vocabulary
Eight current CSIV seed tokens for identity, agent execution, financial transactions, infrastructure changes, and key ceremonies.
Developer Model
The beta SDK shows the practical shape: compile a local vocabulary, create a bounded token, sign it, then verify and resolve before dispatch.
Token Builder
Create bounded intent tokens from vocabulary version, intent name, context, params, and nonce
Verify and Resolve
Check signature, expiry, context, params, required proofs, and handler mapping in one fail-closed call
Tool Adapter
Map MCP or agent tool calls into known Logos tokens before any handler dispatch
Schema Validation
Validate vocabularies, tokens, and signed envelopes before accepting them across a boundary
.logos Compiler
Compile readable vocabulary files into canonical JSON and generated TypeScript helper builders
Local Logic Library
Resolve known tokens to local handlers without prompt parsing or executable command payloads
Integration Example
Vocabulary and signed token
import { compileLogos, LogosLexicon } from '@silentauth/logos-lexicon';
const { vocabulary } = compileLogos(`
vocabulary silentauth.agent.v1
intent CSIV_EXEC_001 agent.execute {
risk: 4
context: ai_agent_runtime
params: agentId, toolName, actionHash
proofs: human_approval, vinac_fm_level_3
handler: agents.execute
}
`);
const lexicon = new LogosLexicon();
lexicon.registerVocabulary(vocabulary);
const token = lexicon.createToken({
vocabularyVersion: 'silentauth.agent.v1',
intent: 'agent.execute',
context: 'ai_agent_runtime',
params: {
agentId: 'agent_local',
toolName: 'deploy_service',
actionHash: 'sha256:...'
},
nonce: 'fresh-nonce'
});
const signed = await lexicon.sign(token, {
keyId: 'server-key-1',
secret: process.env.LOGOS_HS256_SECRET!
});Verify and resolve before dispatch
const result = await lexicon.verifyAndResolve(signed, {
secret: process.env.LOGOS_HS256_SECRET!,
resolution: {
context: 'ai_agent_runtime',
satisfiedProofs: [
'human_approval',
'vinac_fm_level_3'
]
}
});
if (!result.ok) {
throw new Error(`Logos denied: ${result.reason}`);
}
await handlers[result.resolved.handler](result.token.params);Tool-call adapter
import { createToolCallToken } from '@silentauth/logos-lexicon';
const mapped = createToolCallToken(
lexicon,
{ name: 'deploy_service', input: { service: 'api', environment: 'prod' } },
[{
toolName: 'deploy_service',
vocabularyVersion: 'silentauth.infra.v1',
intent: 'infra.deploy',
context: 'ci_cd',
paramMap: { service: 'service', environment: 'environment' }
}],
{ context: 'ci_cd', satisfiedProofs: ['maintainer_approval'] },
'fresh-nonce'
);
if (!mapped.validation.ok) {
throw new Error(mapped.validation.reason);
}Use Cases
AI Agent Pipelines
Replace natural language instruction passing between agents with typed semantic tokens. Every action is pre-agreed, bounded, and auditable, with no prompt injection path.
Cross-System Automation
Coordinate microservices, IoT devices, and ML models with a common semantic vocabulary. A token emitted by a sensor is resolved identically in cloud infrastructure.
Physical-Digital Bridging
Bind digital actions to physical presence using VINAC-FM as the transport. The Logos Lexicon token carries the semantic intent; the acoustic channel proves it is legitimate.
Zero-Trust M2M Auth
Remove implicit trust from machine-to-machine calls. Every action is an explicit token resolved against a pre-shared, locally-auditable logic library.
Traditional Messaging vs. Logos Lexicon
Traditional M2M
Logos Lexicon
Included In Open Preview
Logos Lexicon is part of the shared SilentAuth preview workspace. Pricing tiers are intentionally disabled while the vocabulary, VINAC-FM binding, and local gateway path are validated.
The grammar of machine coordination
Stop passing instructions. Start exchanging pre-agreed intent references that resolve locally under versioned policy.
