InfinityID Labs — human interface layer

The interface
leaves the
screen.

HoloDock is a pocket-sized optical engine that turns an ordinary phone into a spatial computer. The phone keeps the compute, storage and apps. HoloDock adds the light field, the depth sensing and the space to put things in.

See the device Request developer access

Form factor: 138 × 52 mm
Optical nodes: 12 · Metatron lattice
Connection: Single USB-C
Host: iOS · Android

01The gap

Compute is solved.
The interface is not.

Spatial computing does not need another computer. It needs a hardware interface layer that the computer people already carry can plug into.

01 — Flat

The phone has no depth

Every capable computer already lives in a pocket — compute, storage, connectivity, apps. What it cannot do is put anything in the room with you.

02 — Heavy

Headsets ask for too much

Standalone spatial hardware duplicates the phone, then asks people to wear it. The compute problem was solved a decade ago; the interface problem was not.

03 — Closed

Apps have nowhere to go

Developers have no sanctioned route from an existing mobile app to a spatial surface — so spatial computing stays a separate platform instead of a new output.

InfinityID builds the layer between them — one identity, one spatial context, one interface, across the phone you own and the space you are standing in.

02The device

HoloDock

A handheld optical engine, not another computer. Twelve nodes on a Metatron lattice carry the projection, sensing and anchoring hardware; the phone on the other end of the cable does the thinking.

How it works

Three moves, and none of them are setup. The dock is a display and a sensor package — the phone stays the computer, and SpatialOS does the rest.

Explore the device from the inside

01Plug into your phone
Connect
The dock takes the phone's USB-C port. One cable carries power and data at full speed — nothing to pair, nothing to charge, nothing to configure.
02Open the InfinityID app
Launch
SpatialOS claims the dock, calibrates the projection against the room in front of it, and takes over the render loop.
03Enjoy the holographic experience
Project
The display pyramid folds the phone's output into a true 3D image above the screen. Move around it and the parallax holds.

Indicator light

Session state at a glance — idle, live, projecting

Touch button

One control: wake, capture, dismiss the scene

USB-C port

Power and data · high-speed interface

52 × 14 mm

Pocket-sized body, no case needed

Holographic projection3D floating visuals

Plug & playNo pairing needed

Spatial trackingIMU + depth sensing

App & SDK supportiOS + Android

High performanceLow-latency rendering

Developer readyPlugins, APIs, tools

Volumetric light engine

Micro-OLED stack + waveguide · 60 fps light field

Holographic display pyramid

Reflections fold into a true 3D floating image

Depth & LiDAR module

0.2–4 m reconstruction · 30 Hz environment mesh

AI vision cameras

Stereo RGB · 120° FOV · passthrough capable

Spatial audio array

4-mic beamforming · dual full-range drivers

USB-C host link

Power, video and MCP transport on one cable

Exploded view — 12 structural modules

01Holographic projection lens
02Light field engine
03Micro-LED array
04Beam shaping optics
05LiDAR & depth module
06AI vision cameras
07Sensor fusion board
08Spatial co-processor (NPU)
09Power management board
10Battery module
11Thermal management
12Core structure frame

Dimensions

52 × 14 mm dock body

Controls

Single touch button · status indicator

Optical engine

Micro-OLED + waveguide · 60 fps

Depth

LiDAR + stereo pair · 0.2–4 m

Compute

On-module NPU · host GPU offload

Power

USB-C PD passthrough from the host

Materials

Aviation-grade aluminium · sapphire optics

Host support

iOS 17+ · Android 14+

Protocol

Native MCP server · OpenCV bridge

Specifications describe the current engineering target and are subject to change before production.

03The platform

Three layers.
One interface.

Complexity happens underneath: optics, sensor fusion, permissions, transport. Above the line, a developer positions an object in space and it appears.

HoloDock

Hardware

The optical engine. It carries projection, depth sensing and spatial anchoring — and no user data. One USB-C cable is the whole integration surface.

Micro-OLED light engine
LiDAR + stereo depth
IMU and spatial anchors
Foldable optical assembly

SpatialOS

Phone runtime

The control centre that runs on the phone. It composes the scene, drives calibration, and renders every frame the dock projects.

Hologram Studio
Device manager & calibration
Spatial app builder
AI-assisted scene generation

Openware

Extension platform

A sanctioned plugin model, not injection into other people's apps. Developers adopt the SDK and declare the capabilities they need.

Plugin manifest
Capability permissions
Android + iOS SDK
InfinityID plugin store

Signal path — intent to light

01Agent services
02Openware API
03Platform SDK
04InfinityID app
05Spatial runtime
06HoloDock SDK
07Optical engine
08Spatial output

04SpatialOS

One runtime.
Every surface.

HoloDock is the hardware half. SpatialOS is the other one: phone apps, spatial interfaces, AI agents, MCP servers, developer plugins, cloud services, identity and permissions, all addressed through a single runtime.

System architecture — select any node

01Rendering and positioning

Spatial Runtime

Everything to do with where things are and how they are drawn. The runtime turns a scene graph into a calibrated light field the dock can project, and keeps it anchored while the room and the phone move.

Capabilities

3D scene management
Spatial anchors
Object positioning
Holographic rendering
Depth mapping
Gesture targets
Persistent scenes
Environment mapping
Spatial UI components
Projection calibration
Device orientation
Input mapping

Developer API

spatial.scene.create()
spatial.anchor.create()
spatial.object.place()
spatial.environment.scan()
spatial.input.onGesture()
spatial.device.calibrate()

05Openware

Give an app
somewhere to stand.

Openware is an extension model, not a way to modify apps you do not own. A developer adds the SDK, declares capabilities in a manifest, and the app gains a spatial surface on any paired dock.

infinityid.plugin.toml

# infinityid.plugin.toml
[plugin]
app = "com.example.fitness"
sdk = "openware/1.0"

[capabilities]
spatial            = "required"
holographic_output = "required"
camera             = "required"
motion             = "required"
microphone         = "optional"

[[surface]]
kind   = "model"
id     = "body.skeleton"
anchor = "user.front"

[[surface]]
kind   = "panel"
id     = "rep.counter"
anchor = "world.left"

[[surface]]
kind   = "agent"
id     = "form.coach"
voice  = true

01
Music
Playback controls become an anchored spatial visualiser.
02
Maps
Turn-by-turn navigation laid over the room and the route ahead.
03
Fitness
A live skeleton beside you, with form correction from an agent.
04
Camera
Captured depth replayed as a volumetric photo you can walk around.
05
Messaging
Conversations as floating panels anchored where you left them.
06
CAD
Models lifted off the screen at true scale before they are machined.

On platform rules: Openware never injects into third-party applications. Both mobile platforms restrict that, and it would be the wrong architecture regardless — a declared manifest scales, a hack does not. Plugins ship because their authors chose to ship them.

06MCP Gateway

Keep your backend.
Connect it once.

You do not rebuild your services to go spatial. Register the MCP server you already run, choose which tools SpatialOS may call, and the Agent Kernel can use them the moment the scene needs them.

Path of a tool call

01SpatialOSSession, identity, scene
02Agent KernelIntent, plan, tool choice
03MCP ClientBuilt into the runtime
04InfinityID MCP GatewayPolicy, audit, rotation

Dev MCP Server
stdio · your laptop
App MCP Server
HTTPS · your backend
Device MCP Server
USB-C · the dock
Cloud MCP Server
SSE · shared org tooling

InfinityID dashboard — connect MCP server

Not connected

Server nameServer URLTransport

stdio is for local development against a server on your own machine.

AuthenticationEnvironment

Interface preview — no request leaves this page.

Connected MCP server — fitness_backend · Development

12 tools discovered · 7 shown

Input schema
{ "projectId": "string", "readOnly": "boolean?" }
Permissions
projects:read
Allowed agents
Any agent in this project
Allowed devices
Phone · HoloDock
Test tool

Security layer

Nothing executes before the policy chain agrees.

01App
02Identity
03Permission manifest
04Agent policy
05MCP policy
06Device policy
07Execute

Tool-level permissions
Each tool is granted, not the server as a whole.
User approval
Consent-scoped tools prompt the person, per call.
Device permissions
A tool can be allowed on the dock and denied on the phone.
Agent permissions
Named agents, not every agent in the org.
Scoped API keys
One key per project, environment and capability set.
Token rotation
Rotate from the dashboard without redeploying the app.
Audit logs
Every call recorded with caller, device, arguments and result.
Revocation
Kill a server, a tool or a key and calls stop mid-session.
Environment separation
Local, development and production never share credentials.

07Developer onboarding

Build your first
spatial app.

Connect your app, your agent or your MCP server to SpatialOS in minutes. The simulator means you can finish the whole loop before a HoloDock exists on your desk.

From idea to spatial app

InfinityID removes the need to build separate systems for hardware control, spatial rendering, agents and external tools. Developers connect them through one platform.

01Idea
02Create project
03Connect app
04Connect MCP
05Add agent
06Add spatial UI
07Simulate
08Device test
09Publish

Step 03

Select capabilities

Pick what the app is allowed to reach. Selections become the permission manifest in step 09 — nothing is granted implicitly.

5 selected · written into the permission manifest

infinityid.app.json

{
  "name": "Spatial Fitness Coach",
  "version": "1.0.0",
  "platform": [
    "ios",
    "android"
  ],
  "capabilities": [
    "camera",
    "pose",
    "voice",
    "spatial"
  ],
  "agents": [
    "fitness_coach"
  ],
  "mcpServers": [
    "fitness_backend"
  ],
  "spatialViews": [
    "coach",
    "rep_counter",
    "body_model"
  ]
}

Spatial app manifest

One file describes the whole app.

Platforms, capabilities, agents, MCP servers and spatial views in a single declaration. The dashboard reads it, the runtime enforces it, and the store shows the user what it asks for before they install.

platform — where the app runs
capabilities — what hardware it may reach
agents — which agents may act on its behalf
mcpServers — which tool servers it depends on
spatialViews — the surfaces it projects

08Openware dashboard

One console.
Every moving part.

Projects, MCP servers, discovered tools, paired devices, saved scenes, keys and audit logs — the whole spatial deployment in one place, per environment.

Overview

Spatial Fitness Coach · development

Project status: Healthy
Connected apps: 3
Connected agents: 2
MCP servers: 4
Devices: 2 docks · 5 phones
Spatial sessions: 1,284
API usage: 9,417 calls
Errors: 6
Recent deployments: build 128

Build for the spatial web.

Connect your apps, agents and tools to InfinityID SpatialOS and start building interfaces that move beyond the screen.

Start building Connect MCP server View documentation Request HoloDock dev kit

SDK access can begin before HoloDock hardware is available, using the SpatialOS simulator.

09Principles

Human. Intelligence.
Security.

Three commitments that shape every decision in the stack — and the order they are weighed in when they conflict.

Human

Human interface layer

The system reads people, not commands. Presence, attention and intent are first-class inputs — so the interface can be spoken to, pointed at, or simply stood in front of.

Voice
Gesture
Vision
Spatial position
Attention
Interaction

Intelligence

Agent layer

Agents that reason over what the device can see and hear, running on the phone where latency matters and in the cloud where scale does.

Assistants
Agents
Multimodal reasoning
Local inference
Knowledge graphs
Tool calling

Security

Trusted device layer

A device that watches a room has to be accountable to the person holding it. Capabilities are declared, granted per plugin, and revocable — and sensor data stays under the user's control.

Identity
Permissions
Encrypted transport
Device pairing
Capability scopes
User-held data

10Human input

Talk to the page
the way you would the device.

The same intent router that drives the dock runs this site. Say a command, or type it — both resolve through one grammar.

“Hey Infinity — show me the device, then open the developer access form.”

Wake: A far-field phrase opens the channel without touching anything.
Intent: Speech resolves to an intent, not a transcript to search.
Fallback: Every intent is reachable by typing, on any browser or device.

Speech recognition runs in your browser. Nothing is recorded, and no audio leaves the device — the transcript is matched against the intents listed opposite and then discarded.

Voice command centre○ standby

awaiting voice input…

idle — awaiting input

Live speech capture is unavailable in this browser — the text console runs the same intents.

"Show the device"device
"Show the platform"stack
"Show SpatialOS"spatialos
"Connect an MCP server"mcp-gateway
"Build a spatial app"build
"Open the dashboard"dashboard
"Explain Openware"openware
"Open the SDK"mcp
"Request access"access
"Go to top"top

11Developers

A dock is
an MCP server.

Every HoloDock exposes its sensors and its light field as Model Context Protocol tools. No driver glue, no bespoke bridge — agents discover the hardware the same way they discover anything else.

# Bind an agent to the HoloDock's Camera MCP server.
import mcp.client as mcp


async def main():
    async with mcp.connect("mcp://dock.local:8080/camera") as dock:
        # Discover what this dock exposes.
        tools = await dock.list_tools()

        # Capture a depth frame for volumetric rendering.
        frame = await dock.call_tool(
            "quick_capture",
            {"mode": "holographic_depth", "device_index": 0},
        )
        print(frame.summary())


if __name__ == "__main__":
    import asyncio

    asyncio.run(main())

12Developer access

Get a key.
Start building.

Tell us what you are building and where it runs. The kit, the samples and the documentation you receive are shaped by those two answers.

The interfaceleaves thescreen.

Compute is solved.The interface is not.

The phone has no depth

Headsets ask for too much

Apps have nowhere to go

HoloDock

How it works

Connect

Launch

Project

Three layers.One interface.

HoloDock

SpatialOS

Openware

One runtime.Every surface.

Spatial Runtime

Give an appsomewhere to stand.

Music

Maps

Fitness

Camera

Messaging

CAD

Keep your backend.Connect it once.

Nothing executes before the policy chain agrees.

Build your firstspatial app.

From idea to spatial app

Select capabilities

One file describes the whole app.

One console.Every moving part.

Build for the spatial web.

Human. Intelligence.Security.

Human

Intelligence

Security

Talk to the pagethe way you would the device.

A dock isan MCP server.

Get a key.Start building.

The interface
leaves the
screen.

Compute is solved.
The interface is not.

Three layers.
One interface.

One runtime.
Every surface.

Give an app
somewhere to stand.

Keep your backend.
Connect it once.

Build your first
spatial app.

One console.
Every moving part.

Human. Intelligence.
Security.

Talk to the page
the way you would the device.

A dock is
an MCP server.

Get a key.
Start building.