Proactive interaction infrastructure for consumer AI

Your model is rented.
The relationship isn’t.

LIMEN is the interaction runtime for consumer AI: real-time voice, live perception, persistent memory, and shared context through one connect(). Swap the model underneath and it’s a config change — what your product remembers about each user doesn’t leave with it.

Request early access See how it works →

Own the part that compounds. Productized from the real-time stack behind Sidekick AI, live on Steam.

Web SDK today · designed 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 the primitives per session — and what they accumulate stays with your product, not with whichever model you’re calling this quarter.

Voice

Barge-in-capable, low-latency speech in English and Chinese, with turn timing you tune per audience.

Perception

Screen, camera, or a track you already have, streamed frame-by-frame. A canvas capture needs no permission prompt.

Memory

Persistent recall across sessions and devices, isolated per user and held by your product, not your model vendor.

Context

Live state, tools, and identity injected into every turn — one shared world model, not a prompt you rebuild.

// 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(). Sessions resolve against a presence — persona and providers, configured once.

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.
Declare tools the agent can call on your client — typed, schema-validated, handlers stay local.
Managed cloud runtime. 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
});

// where it came from, where it goes

One layer. Every kind of product.

Extracted from the product below, 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.

Sidekick AI — the proving ground

LIMEN packages the real-time stack behind Sidekick AI, our own AI gaming companion live on Steam. Real-time voice, screen perception, and per-user memory were built and hardened there first — against real players, in long sessions, under constant interruption — then pulled out as infrastructure.

voiceperceptionmemorylive on Steam

Meet Sidekick →

Wearables & earbuds

Low-latency voice with on-device wake and barge-in, tuned for low-power radios and intermittent connectivity. What accumulates: routine and preference — the things a user should not have to say twice.

voicememorylow-power

Companion robots

Fuse camera, depth, and audio into a shared world model so the robot perceives the room. What accumulates: who it is with, and the history it shares with them.

perceptionmemorymultimodal

Desktop agents

Stream the screen frame-by-frame so the agent sees what the user sees, then acts with full context and tools. What accumulates: the shape of the work — what is being built, and where it was left.

perceptioncontextscreen

Voice toys & kiosks

Drop-in conversational presence with a chosen voice and per-modality consent built in. What accumulates: per-user continuity across visits, on shared hardware.

voicecontextturnkey

// 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 isolationPer-tenant meteringConsent-scopedBring your own model keys

Memory export and deletion, and in-country hosting, are pilot-contract deliverables rather than shipped features. 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.

Isolated by default

One user’s memories never surface to another, and every session is configured and metered against its own tenant.

Config changes are audited

Every configuration write goes through an audited path. An unaudited change is not representable.

// questions

Before you start building.

What exactly does LIMEN provide?

LIMEN is the interaction runtime between your AI model and your product: real-time voice, screen and sensor perception, persistent memory, and shared context over a single session. Model vendors ship memory too, but theirs stops at their boundary; what LIMEN holds spans sessions, devices, and modalities, and survives a change of vendor. Learning from the outcome of each interaction is the layer we’re building on top — in development, validated against Sidekick, not a shipped feature.

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 interaction runtime is independent of the intelligence layer, so a change of model vendor is a config change, not a rebuild.

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 one user’s memories never surface to another. Every configuration write goes through an audited path. Memory export and deletion, and in-country hosting, are pilot-contract deliverables rather than shipped features — we would rather say so than imply otherwise.

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 before general availability.

early access · request

Own the part
that compounds.

We’re onboarding early-access design partners now. Join the waitlist to build against the web SDK before general availability.