Open SDK beta semantic intent layer

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

This layer

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

01

State-Frame Token Generation

Vocabulary version, intent ID, context bits, parameter indexes, and nonce or session references become a compact state frame.

02

Transport Validation

VINAC-FM, NFC, QR, optical, wired, or network transport supplies delivery and proof metadata. The token itself stays transport-independent.

03

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.

Token IDNamespaceRisk TierDescription
CSIV_AUTH_001auth.identityhighBind and authenticate an identity session
CSIV_AUTH_002auth.identityhighBind same-device identity with stronger context
CSIV_EXEC_001agent.executionhighAuthorize a high-risk AI agent tool action
CSIV_EXEC_002agent.executioncriticalAuthorize critical execution with stronger proof
CSIV_TXN_001finance.transactionshighAuthorize a standard value-limited transaction
CSIV_TXN_002finance.transactionscriticalAuthorize a high-value transaction with strict proof
CSIV_INFRA_001infra.operationscriticalAuthorize infrastructure mutation or deployment
CSIV_KEY_001security.keyscriticalAuthorize key ceremony or secret rotation

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

Text to packet to parse to interpret to execute
Instructions transmitted over the wire
Remote code execution surface
Variable interpretation per implementation
Presence proof bolted on later
Susceptible to prompt injection

Logos Lexicon

Semantic token -> resolve -> execute
No instructions transmitted, ever
Locally resolved logic library
Deterministic, bounded execution
Explicit presence and policy requirements
No prompt parsing path by design

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.

Logos 2.0 seed vocabulary
JavaScript and TypeScript SDK examples
Local policy evaluation model
VINAC-FM transport binding docs
Receipt and audit export model
Custom namespace design notes

The grammar of machine coordination

Stop passing instructions. Start exchanging pre-agreed intent references that resolve locally under versioned policy.