Semantic Protocol — v1.0 Vocabulary Live

Logos Lexicon

A Transport-Agnostic Compact Semantic Intent Protocol

Replace instruction passing with deterministic token resolution. Machines coordinate through a shared, physics-bound vocabulary — no parsing, no interpretation, no injection surface.

Start Building Read the Protocol Spec

Four Foundational Principles

Logos Lexicon is not a messaging format. It is a coordination grammar — a closed vocabulary of pre-agreed semantic tokens resolved locally without instruction parsing.

Execution Without Instructions

Agents never transmit raw instructions. A compact semantic token is emitted — resolved locally by the receiving machine's logic library into a deterministic action.

Transport-Agnostic

The same CSIV token resolves identically whether transmitted over acoustic, optical, UWB, NFC, or wired channels. The protocol is independent of the physical layer.

Physics-Bound Hardware Gating

Before any token reaches the logic library, it must pass the Hardware Constraint Engine — FFT analysis and proximity gating verify the signal is physically present and unforged.

Air-Gapped Logic Libraries

Logic libraries are pre-agreed and locally stored. No remote code execution. No instruction injection. Meaning is resolved deterministically from a closed, auditable vocabulary.

The Semantic Coordination Stack

Logos Lexicon sits between human policy intent and physical transport — ensuring every signal is semantically meaningful and physically validated before execution.

Human Policy Layer

Human Intent / Policy Logic Library

↓

Logos Lexicon

CSIV Vocabulary + Semantic Token Generator

This layer

Physics-Bound HW Constraint

FFT Analysis, Attenuation & Proximity Gating

↓

Transport Abstraction

Acoustic · Optical · UWB · NFC · Wired

How It Works

From human intent to deterministic execution in three steps

State-Frame Token Generation

Intent + Context + Parameters are combined into a compact State-Frame token by the Semantic Token Generator. The token is bounded, versioned, and carries no executable instructions — only a resolved intent ID.

Physics-Bound Hardware Validation

Before the token is accepted, the Hardware Constraint Engine performs FFT analysis and proximity gating on the physical signal. Only signals that pass mathematical constraints are permitted to reach the logic library.

Local Logic Library Resolution

The validated token is matched against the receiving machine's pre-shared, air-gapped logic library. Meaning is resolved locally — deterministically — into an execution action with bounded parameters and safety constraints.

CSIV Vocabulary v1.0

Eight pre-built semantic tokens covering authentication, agent execution, financial authorization, infrastructure, and key ceremony operations.

Token IDNamespaceRisk TierDescription

CSIV_AUTH_001auth.identityhighStandard Layer 4 identity bind

CSIV_AUTH_002auth.identityhighSame-device enforcement

CSIV_EXEC_001agent.executionhighAI agent action approval

CSIV_EXEC_002agent.executioncriticalCritical execution gate

CSIV_TXN_001finance.transactionshighFinancial transaction auth

CSIV_TXN_002finance.transactionscriticalHigh-value wire / crypto

CSIV_INFRA_001infra.operationscriticalInfrastructure mutation

CSIV_KEY_001security.keyscriticalKey ceremony operation

Full vocabulary reference ·SDK reference

Developer SDK

@silentauth/logos-lexicon — a zero-dependency TypeScript SDK for browser and Node.js

Token Generator

Create State-Frame tokens from Intent + Context + Parameters with a single call

Policy Evaluator

Evaluate any CSIV token against your logic library — returns allow/deny + required verification layer

Namespace Resolver

Resolve namespaced actions (auth.identity, agent.execution) to their execution policy

Schema Validation

Validate intent declarations against the CSIV schema before transmission

Vocabulary Client

Fetch and cache the active vocabulary from the SilentAuth API with full TypeScript types

Logic Library SDK

Bootstrap a local logic library in any Node.js or browser environment with zero dependencies

Integration Example

Token Generation — Agent A

import { LogosLexicon } from '@silentauth/logos-lexicon';

const lexicon = new LogosLexicon({
  publicKey: 'pk_live_…',
  version: '1.0.0',
});

// Generate a State-Frame token for agent action
const token = await lexicon.generate({
  intent: 'CSIV_EXEC_001',
  context: {
    session_id: 'sess_abc123',
    agent_id:   'agent_gpt4o',
    timestamp:  Date.now(),
  },
  parameters: {
    action: 'read_customer_data',
    scope:  ['id', 'email'],
  },
});

// token.id → 'CSIV_EXEC_001'
// token.state_frame → compact binary representation
// token.version  → '1.0.0'

Policy Resolution — Agent B (Receiver)

import { LogosLexicon } from '@silentauth/logos-lexicon';

const lexicon = new LogosLexicon({
  publicKey: 'pk_live_…',
  version: '1.0.0',
});

// Resolve incoming token against local logic library
const result = await lexicon.resolve(receivedToken);

if (result.allowed) {
  console.log(result.action);
  // {
  //   label:          'authorize_agent_action',
  //   namespace:      'agent.execution',
  //   required_layer: 4,
  //   risk_tier:      'high',
  //   execution_policy: {
  //     max_uses: 1,
  //     rate_limit_per_hour: 20,
  //     approval_window_seconds: 300
  //   }
  // }
}

Policy Evaluation — standalone, no network required

import { evaluatePolicy } from '@silentauth/logos-lexicon';

// Evaluate offline — logic library is locally bundled
const decision = evaluatePolicy({
  token_id: 'CSIV_TXN_002',
  context:  { value_usd: 25000, dual_approved: false },
});

// { allowed: false, reason: 'dual_approval_required', required_layer: 4 }

Use Cases

AI Agent Pipelines

Replace natural language instruction passing between agents with typed semantic tokens. Every action is pre-agreed, bounded, and auditable — no prompt injection surface.

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 → Packet → Parse → Interpret → Execute

✕Instructions transmitted over the wire

✕Remote code execution surface

✕Variable interpretation per implementation

✕No physics-bound presence proof

✕Susceptible to prompt injection

Logos Lexicon

Semantic Token → Resolve → Execute

No instructions transmitted, ever

Air-gapped, locally resolved logic

Deterministic, bounded execution

Physics-bound hardware gating

Zero injection surface by design

Logos Lexicon Plans

Pro

$29/per month

Full CSIV v1.0 vocabulary access
Up to 50,000 token resolutions / mo
JavaScript + TypeScript SDK
REST API access
Vocabulary versioning
Email support

Start Pro Trial

The grammar of machine coordination

Stop passing instructions. Start speaking in pre-agreed semantic tokens — deterministic, physics-bound, and injection-proof by design.

Get Started Free Read the Protocol Spec