Real-time presence infrastructure for AI

Give your product
a person, not an API.

LIMEN is real-time presence infrastructure for AI products: voice, perception, memory, and context through one connect(). Bilingual, and it runs in the cloud or fully offline on your own hardware.

Request early access See how it works →

Ship presence, not plumbing. Productized from the real-time stack behind Sidekick AI, live on Steam.

Web SDK today · built for every device class

WearablesCompanion robotsDesktop agentsVoice toysIn-car & kiosk

// one layer · four primitives

Everything an AI needs to feel present.

The hard real-time problems, already solved and on the wire. Compose them per session and toggle modalities turn by turn.

Voice

Barge-in capable, low-latency speech in English and Chinese. Pick a voice or bring your own model.

Perception

Screen, camera, and sensor understanding streamed frame-by-frame to the model.

Memory

Persistent, per-user recall across sessions and devices. Forget on command.

Context

Live state, tools, and identity injected into every turn. One shared world model.

// the integration path

One session. Every modality.

A single real-time connection carries audio, frames, and context both ways. You decide which senses are live at each turn.

Open a session

Authenticate and call connect(). LIMEN negotiates a low-latency transport to the nearest edge.

Stream the senses

Push mic audio and screen or camera frames over a single WebRTC channel, no pipeline to build.

Toggle modalities

Flip voice, perception, and memory on or off per request as the interaction changes.

Ship the presence

Receive transcripts, intents, and synthesized speech. Your AI is present.

// the developer surface

An SDK,
not a pipeline.

Open a session, stream audio and frames over WebRTC.
Toggle voice, perception, and memory per request.
Runs fully offline on your hardware, or in the cloud. Your model or ours.
Events for speech, intent, and perception, fully typed.

// the web SDK is built and documented.
Want early access? Request it below.

javascriptcopy

import { Limen } from "@limen/sdk";

// one session: voice, perception, memory, context on the wire
const session = await Limen.connect({
  presence: "nova",
  language: "auto",   // EN + ZH, routed per turn
});

// turn senses on per turn
session.startPerception("screen");

session.on("speech", (turn) => {
  console.log(turn.text);  // low-latency, streamed
});

// presence, per form factor

One layer. Every kind of product.

The web SDK ships today. The same provider-pluggable stack is built to adapt to each device class as those SDKs land, from battery-bound wearables to always-on desktop agents.

Wearables & earbuds

Low-latency voice with on-device wake and barge-in, tuned for low-power radios and intermittent connectivity.

voicememorylow-power

Companion robots

Fuse camera, depth, and audio into a shared world model so the robot perceives the room and remembers who it's with.

perceptionmemorymultimodal

Desktop agents

Stream the screen frame-by-frame so the agent sees what the user sees, then acts with full context and tools.

perceptioncontextscreen

Voice toys & kiosks

Drop-in conversational presence with a chosen voice, persistent per-user memory, and per-modality consent built in.

voicecontextturnkey

4 primitives

one connect()

0 keys

runs fully offline

2 languages

EN + ZH, routed per turn

1 SDK

web today, more on the roadmap

// real-world lineage

Productized from a stack that ships in a real product.

LIMEN packages the real-time stack behind Sidekick AI, our own AI gaming companion live on Steam. The hard parts, real-time voice, screen perception, and per-user memory, were built and proven there first, then pulled out as infrastructure.

Meet Sidekick →

// trust & data handling

Real-time senses, handled responsibly.

Voice, screen capture, and sensor data are sensitive by nature. LIMEN is built so you can give your AI presence without giving up control of what it perceives or remembers.

Per-user isolationOn-device / on-prem optionConsent-scopedYour keys, or none

Formal certification (SOC 2, GDPR, HIPAA) is on the pilot roadmap, not yet audited. We say what is true today.

Encrypted in transit

Every session stream is encrypted in transit over DTLS-SRTP and TLS 1.3.

Scoped consent

Per-modality permissions and clear in-session indicators when senses are live.

Memory you control

Inspect, export, or forget per-user memory on command. Nothing is sticky by default.

Edge & on-device

Keep sensitive frames on the device or on your own hardware, with data residency you choose.

// questions

Before you start building.

What exactly does LIMEN provide?

LIMEN is real-time presence infrastructure between your AI model and your device. It carries voice, screen and sensor perception, persistent memory, and shared context over a single session, so you ship the product and skip building the real-time stack yourself.

Do I bring my own model, or use yours?

Either. LIMEN routes the senses to whatever model you point a session at: your own, a hosted one, or ours. The presence infrastructure is independent of the intelligence layer.

Which device classes are supported?

The web SDK (TypeScript over WebRTC) ships today. Unity and Swift adapters are on the roadmap; the provider-pluggable stack is built to adapt to each form factor's latency, power, and connectivity constraints as those SDKs land.

How is sensitive data handled?

Streams are encrypted in transit, modalities are consent-scoped with live in-session indicators, and per-user memory can be inspected, exported, or forgotten on command. Frames can stay on-device or on your own hardware for data residency.

Can I try it before it's generally available?

Yes. We're onboarding early-access design partners now. Request access below and you can build against the web SDK and the fully-offline local stack before general availability.

early access · request

Ship presence,
not plumbing.

We're onboarding early-access design partners now. Join the waitlist to build against the web SDK and the fully-offline local stack.