How to create immersive apps with AI assistants and spatial computing

Introduction: Developing immersive experiences is easier than you think

In recent months, AI assistants based on on-device agentic models have revolutionized how we interact with the digital space. Thanks to advances such as Liquid AI's new LFM2.5-2.6B and Cloudflare's browser-first agent Kitesurf, creating applications that understand location, orientation, and physical context is now within reach of every developer.

This article explains step-by-step how to integrate AI assistants into spatial computing to develop truly immersive experiences, with practical examples and ready-to-use code snippets.

Why spatial computing is the perfect complement to AI assistants

Spatial computing adds the concept of "where" to the data that AI assistants already process. When an assistant knows the user's exact location, it can provide contextual suggestions, augmented reality (AR) directions, and gesture controls that feel natural, almost as if the AI were part of the surrounding environment.

• Contextual positioning: real-time location-based suggestions.
• Gesture interfaces: touchless control via hand movements.
• AR/VR integration: overlaying digital information onto the physical world.
• Multi-user collaboration: spatial coordination for shared experiences.

The latest game-changing releases (2026)

Recently,Liquid AIreleased LFM2.5-2.6B, a 2.69B parameter agentic model that performs planning, tool calling, and complex task completion entirely on-device, without needing cloud connectivity. This means assistants can now understand the surrounding space and act locally, ensuring zero latency and maximum privacy.

Microsofthas open sourced a polyglot unit-test generation agent that achieves 92.1% task completion, significantly outperforming standard copilots. This tool is particularly useful for automatically testing spatial flows.

CloudflareintroducedKitesurf, a browser-first agent that runs in an isolated V8 on Cloudflare Workers, opening new possibilities for location-based web interactions without native apps.

How to build a spatial navigation assistant: a practical example

Imagine we want to create an assistant that helps a user find the nearest exit in a large department store, displaying an AR directional arrow on their device. Below is a complete pipeline that combines LFM2.5-2.6B, sensor fusion, and an AR rendering module.

1. Set up the environment

```bash pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu pip install numpy pygame --upgrade pip install spatial-ai-sdk # unified library for sensors and LLMs ```

2. Acquire sensor data and map the space

```python import spatial_ai as sa import numpy as np # Initialize the location module (example with Wi-Fi + IMU) locator = sa.SensorFusion(wifi_map='store_map_wifi.json', imu_sample_rate=50) # Acquire real-time position position = locator.get_position() ```

3. Create a prompt for the AI assistant

```python from liquid_ai import LFM2_5 llm = LFM2_5(model_path='lfm2.5-2.6b.onnx') def build_prompt(current_pos, map_data): return f""" Role: Spatial navigation assistant in a store. Facts: - The user's current location is {current_pos}. - The store map includes the following exits: {map_data['exits']}. Task: Choose the nearest exit, calculate the shortest path, and provide an augmented reality direction (angle and distance). Output format: {{'exit_id': int, 'angle': float, 'distance': float}} """ prompt = build_prompt(position, store_map) response = llm.generate(prompt) ```

4. Visualize the AR direction

```python from pyar import ARRenderer result = json.loads(response) renderer = ARRenderer(device='hololens') renderer.draw_arrow(angle=result['angle'], distance=result['distance'], color=(0, 255, 0, 255)) ```

Leverage modern tools to accelerate development

Even though the code above is minimal, the power of modern agents lies in their ability to plan, call tools, and iterate. Microsoft's polyglot test-generator can be integrated to automatically verify that navigation logic complies with accessibility and safety standards.

For web developers, Kitesurf allows testing spatial flows directly in the browser, simulating mobile device behavior without additional hardware.

Security, privacy, and compliance considerations

• On-device data:LFM2.5-2.6B runs everything locally, reducing the attack surface.
• Transparency:Always clearly indicate when an action is AI-driven.
• GDPR/CCPA compliance:Never send raw location data to the cloud unless the user explicitly consents.

Takeaway: 5 concrete steps to get started

1. Install a sensor fusion SDK (e.g., spatial-ai-sdk) to combine Wi-Fi, Bluetooth, and IMU.
2. Acquire a map of the store or environment in a compatible format (JSON, GeoJSON).
3. Build a prompt that asks the LLM to suggest safe exits and AR directions.
4. Integrate a lightweight AR renderer (e.g., pyar) to display arrows or overlays.
5. Use Microsoft's test-generator to automatically verify navigation logic.

Conclusion: The future of immersive apps is already here

AI assistants and spatial computing are converging to create experiences that are not only informative but truly contextual. Thanks to on-device models like LFM2.5-2.6B, tools like Microsoft's polyglot test-generator, and browser-first agents like Kitesurf, developers can now create sophisticated AR/VR interfaces without dealing with cloud complexity or worrying about user privacy.

Start today with a simple map and a prompt: you'll see how an AI assistant can transform a physical space into an intelligent, responsive assistant.