ContextIQ is the core library behind voice-first, on-device assistants. Private by architecture, fast by design, and genuinely useful in the hand.
Three things tomorrow. Your first is a 9:00 stand-up, and you're clear after 3pm.
Wed, 3 free hours
3 events · nothing after 15:00
The whole model runs locally. There are no API keys, no per-call cost, and no round trip to a server. That constraint is what makes the experience both trustworthy and instant.
Requests, transcripts and results never leave the device. Privacy isn't a policy bolted on afterwards; it's a property of where the compute happens. Cloud escalation, if it exists at all, is opt-in and always announced.
Embedding retrieval routes each request in under a millisecond, with no token cost. Speech is chunked at sentence boundaries so the agent starts talking after the first sentence, not the whole reply.
Every tool call renders as its own view: an event card, a pass, a preview, not a paragraph of text. The agent picks the right tool from a large catalogue, validates every argument, and shows its work when asked.
The tool and routing layers never import model-specific types, so the same engine ports to a second platform later. The hard constraint everything is designed around: a small on-device context window, read at runtime and never hardcoded. Two cross-cutting layers span all five: guardrails, so nothing reaches a tool or the user unchecked, and analytics that measure every decision on the device.
Across every layer
These are the components that make an on-device assistant viable inside a tiny context window. Each is independently testable, portable, and owns one hard problem.
A single source of truth for every tool, wrapped behind a protocol that never leaks model internals. Descriptions are treated as production code, because the summary is the prompt.
Never attach every schema to one session. Cosine-match the utterance against cached embeddings, and only spend a model pass when the top candidates are genuinely close.
Before every request it counts history, prompt and reserve against the runtime context size. When it would exceed, it summarises the oldest turns rather than throwing an error at the user.
Hardware echo cancellation stops the agent hearing itself. Output is cut on real sentence boundaries and queued so speech starts almost immediately, and the user can interrupt at any moment.
Each tool supplies its own result view through a shared protocol. A calendar lookup is an event card; a draft is an editable preview. Nothing destructive runs until the user approves what they can see.
The model is quantised and will hallucinate arguments. Between the call and execution, every argument is checked against its schema, the tool ID is confirmed present, and destructive actions wait for approval.
The whole loop runs locally, in airplane mode, in under two seconds from the end of the sentence.
Gravity-vector gesture with dwell and hysteresis arms the listener.
gestureStreaming transcription with voice-activity endpointing. Live on screen.
on-device STTEmbedding match narrows the catalogue to a handful and attaches only those.
~0.4 msArguments validated, tool runs, result rendered as its own card.
validatedReply chunked by sentence and spoken back, interruptible any time.
<2 s totalBecause the tool and routing layers stay free of any model-specific types, the same registry and the same router move to a second platform without a rewrite. We design the core once and reuse it. The constraint that keeps everything small is also what keeps it clean.
The same on-device assistant adapts to the place it runs in, and is most valuable exactly where connectivity is weakest and people need an answer immediately.
We build the core libraries (tool registries, routing, context budgeting, voice and generative UI) and the products on top of them. Based in London. Reach out for pilots, partnerships or product work.
Start a conversation