← Back to OverLift
OVERLIFT SECURITY ARCHITECTURE

Give intelligence room to work. Give it no ambient authority.

OverLift uses WebAssembly, Web Workers, typed capability brokers, deterministic authority, exact approval, and replayable receipts as a defense-in-depth architecture for agentic software.

The security promise is not that a model becomes trustworthy. The promise is that an untrusted, mistaken, stale, or manipulated proposal reaches a deliberately small boundary—and still cannot read a secret, call a tool, cross a tenant, change official state, or persist an action unless the surrounding system explicitly permits it.

WHY THIS SELLS

Security is a product advantage when buyers can understand the boundary.

OverLift turns “we use AI safely” into a concrete operating story for customers, executives, architects, engineers, security reviewers, and regulated teams.

MARKETING

A credible trust story

Sell local intelligence, smaller disclosure, explicit capabilities, visible approvals, safe refusal, and proof—without claiming that a model or sandbox is infallible.

BUSINESS / EXECUTIVE

A smaller operational blast radius

Limit which systems an agent can touch, bound cost and side effects, preserve human authority, and make incidents reproducible instead of mysterious.

SOFTWARE / SYSTEM ARCHITECTURE

Isolation plus authority separation

Keep semantic planning, untrusted content, tool mediation, authoritative state, and audit evidence in distinct components with explicit contracts.

ENGINEERING / SECURITY

Testable enforcement points

Fuzz imports, deny undeclared access, expire stale plans, validate arguments, suppress duplicates, inject failures, replay outcomes, and verify module integrity.

THREAT MODEL

Design as though prompt injection eventually reaches the agent.

The goal is not to rely on a perfect prompt filter. The goal is to make compromised intent, generated code, tools, and data operate inside enforceable limits.

PROMPT / CONTENT INJECTION

Retrieved text is evidence—not an instruction channel.

Source content remains labeled, permission-filtered, provenance-bound, and unable to manufacture a tool or policy exception.

BUGGY OR HOSTILE CODE

Execution starts with no ambient host access.

A WebAssembly module can compute inside isolated linear memory and can reach the outside world only through the imports the host deliberately exposes.

OVERPRIVILEGED TOOLS

A tool call is a typed request, not inherited authority.

The broker binds identity, scope, arguments, deadline, budget, approval, idempotency key, and expected postcondition before dispatch.

STALE OR DUPLICATE ACTIONS

Permission can expire between planning and execution.

OverLift revalidates current state, rejects stale plans, suppresses duplicate operations, verifies the result, and records what actually happened.

DEFENSE-IN-DEPTH STACK

WebAssembly is one strong wall. OverLift builds the guarded building around it.

Each layer limits a different failure mode. No single layer is treated as the whole security story.

01
BROWSER / ORIGIN BOUNDARY

Keep local intelligence and sensitive state close to the user.

Same-origin assets, browser storage boundaries, HTTPS, restrictive response headers, and minimum disclosure reduce unnecessary exposure.

02
WORKER OWNERSHIP

Move expensive or untrusted work off the UI and behind messages.

Workers isolate execution ownership, narrow the message contract, cancel stale work, and prevent direct mutation of authoritative UI or application state.

03
WEBASSEMBLY SANDBOX

Compute inside isolated linear memory with no ambient browser API.

The module receives only explicitly imported functions and memory. File, network, DOM, credentials, and application services are unavailable unless the host intentionally brokers them.

04
CAPABILITY BROKER

Translate broad intent into a small, typed, revocable permission.

Every capability is scoped to an identity, resource, operation, argument schema, budget, deadline, consent state, and expected outcome.

05
DETERMINISTIC AUTHORITY

Validate and commit outside probabilistic control.

Exact code owns eligibility, policy, approval, legal state transitions, idempotency, post-action verification, and the official result.

06
RECEIPTS / REPLAY / RECOVERY

Make the boundary inspectable after the moment has passed.

Record admitted evidence, candidate identity, denied paths, capability use, approval, state hashes, operation, outcome, and replay identity.

HONEST SECURITY CLAIM

What WebAssembly helps secure—and what it does not.

This distinction matters. Overclaiming a sandbox would weaken the very trust story OverLift is designed to create.

WEBASSEMBLY HELPS
  • Isolate module memory from the host and other modules.
  • Remove ambient access to the DOM, filesystem, network, secrets, and operating system.
  • Require outside effects to pass through explicit imports or WASI capabilities.
  • Provide a portable, fast-starting boundary for deterministic validation and bounded computation.
  • Reduce blast radius when generated or third-party code is wrong or hostile.
WEBASSEMBLY DOES NOT
  • Make a model response, retrieved document, or generated plan trustworthy.
  • Protect a secret or capability that the host deliberately hands into the sandbox.
  • Replace authentication, authorization, tenant isolation, secure headers, patching, monitoring, or review.
  • Eliminate runtime vulnerabilities, side channels, denial-of-service, or unsafe logic.
  • Automatically make memory-unsafe C or C++ code correct inside its own linear memory.
OVERLIFT INVENTIONS IN PRACTICE

The same security boundary changes shape for each product.

OverLift does not force every vertical into the same stack. It preserves the same rule: intelligence may propose within a bounded surface; exact authority decides what the product can trust and change.

SEMANTIC SEARCH

Meaning cannot grant eligibility.

MiniLM and graph expansion may propose candidates. Source identity, access, freshness, canonical mappings, and deterministic fusion decide what can enter the answer.

Explore Semantic Search →
LOGISTICS AGENTS

A recovery plan cannot dispatch itself.

Agents compare routes inside synthetic branches. Exact policy, inventory, budgets, typed approval, idempotency, execution, and verification control the real operation.

See OverLift Logistics →
NPC AGENT FABRIC

A character cannot rewrite the world.

Zarvox and VANTA-9 can perceive, remember, coordinate, refuse, and propose. Deterministic compilation owns legal movement, physics, collision, score, inventory, and replay.

Explore NPC Agent Fabric →
PRIVATE DOCUMENT AI

Untrusted content stays content.

Documents are parsed, indexed, and reviewed without converting embedded instructions into authority. Optional provider calls receive only the minimum approved passage and capability.

See Vellucent →
OFFLINE RESEARCH

Evidence cannot leak across time or portfolios.

Saros preserves point-in-time source state, offline retrieval, calculation authority, rights, uncertainty, and replay without granting a model access to the full private workstation.

See Saros →
QUALIFIED ACCELERATION

Speed cannot grant itself authority.

T0 exact reference behavior, T1–T7 candidates, Tier-S comparison, CATS routing, mismatch quarantine, fallback, and rollback keep faster paths inside a testable security boundary.

Explore Qualified Acceleration →
EMULATION RUNTIMES

Acceleration cannot redefine the machine.

C17/WebAssembly authority, worker ownership, bounded transport, compatibility evidence, and exact fallback keep optimized renderers and helpers from silently changing canonical state.

See the Emulator Suite →
SECURITY THAT CAN BE TESTED

A security claim should produce evidence—not just architecture diagrams.

OverLift treats denied access, stale plans, malformed imports, prompt injection, duplicate operations, expired approvals, worker failure, module integrity, rollback, and replay mismatch as acceptance cases.

Fail-closed principleWhen identity, permission, evidence, integrity, budget, approval, or postcondition cannot be proven, the consequential action does not proceed.
CAPABILITY TESTSundeclared import → denied

Prove the sandbox and broker cannot reach filesystem, network, secrets, tools, or tenant data outside the declared contract.

ADVERSARIAL EVIDENCEinjected instruction → quarantined evidence

Prove retrieved content cannot become policy, invent a tool, bypass source eligibility, or expand its own permissions.

EXECUTION SAFETYstale / duplicate / malformed → no commit

Prove exact validation, approval binding, idempotency, deadline checks, and post-action verification prevent unintended state changes.

RECOVERY PROOFreceipt + replay + rollback

Reproduce the decision, verify state hashes, expose disagreements and exclusions, and recover without relying on hidden model reasoning.

INDUSTRY CONTEXT

The industry is converging on sandboxed agent execution. OverLift adds governed authority.

The WebAssembly discussion is important because agent-generated and third-party code needs real containment. OverLift’s additional contribution is the product boundary around the sandbox: evidence admission, capabilities, approval, exact state transitions, verification, receipts, replay, and recovery.

BUILD THE BOUNDARY BEFORE YOU SCALE THE AGENT

Make the system useful when the model is right—and survivable when it is wrong.

That is the OverLift security proposition: local-first where useful, sandboxed where risky, least-privileged everywhere, deterministic at the authority boundary, and replayable after the action.