Documentation

Everything you need to get intellego running and tuned. It's a v1 preview in active development — packaged installers are coming soon; for now you build from source (a few minutes).

Overview

intellego is a desktop assistant that helps you understand what the other person means during live voice and video calls. Each time they finish a turn, it transcribes their audio locally and shows one small comprehension card:

Tone — their emotional register (warm, impatient, joking-not-serious, neutral).
Decode — the plain-language meaning, unpacking idioms, sarcasm, and hints.
Implied ask — what they want or expect next ("needs a yes/no", "no response needed").
Suggestions (optional) — one to three replies you can use or ignore.

Any facet the model can't provide is left blank rather than guessed. intellego is assistive technology for your own understanding — not for recording or deceiving anyone.

Requirements

OS: Windows 10 / 11 (x64). macOS and Linux are planned for later.
To build from source: Rust (stable), Node.js + npm, and the Tauri prerequisites for Windows (the WebView2 runtime).
For real speech-to-text (optional feature): a C/C++ toolchain (cmake + compiler) for whisper.cpp, plus the whisper and Silero VAD model files (see below).
For a local LLM: a running local provider — Ollama or an OpenAI-compatible endpoint such as an llm-router. Cloud providers work too (opt-in).

Install & build

Packaged release

The first Windows installer is coming soon — watch the Download page. Until then, build from source:

Build from source

Install the prerequisites above (Rust, Node.js, WebView2).

Clone and install frontend dependencies:

git clone https://github.com/losts1/intellego
cd intellego
npm --prefix app install

Build the desktop app:
```
cd app
cargo tauri build
```
or run it in development:
```
cd app
cargo tauri dev
```

The source repo is currently private — access is required until the first public release.

Enabling real speech-to-text and a real LLM

The default build uses a mock transcriber and mock LLM so it runs offline with no heavy dependencies. Turn on the real integrations with cargo features:

cargo tauri dev --features "real-stt,real-llm"

real-stt compiles whisper.cpp + Silero VAD. It needs cmake, a C/C++ compiler, and the model files placed in intellego-audio/models/ (or a directory you set with INTELLEGO_MODELS_DIR):
```
ggml-base.en.bin      # whisper base English model
silero_vad.onnx       # Silero VAD v5
```
real-llm uses a real OpenAI-compatible HTTP provider instead of the mock. Configure it in config.toml (below) or via INTELLEGO_LLM_* environment variables.

Configuration

Copy config.example.toml to config.toml and edit it. config.toml is never committed — it can hold an API key.

[provider]
preset = "llm-router"   # llm-router | ollama | openai | grok
model  = "qwen3.6"
api_key = ""            # required for cloud presets only
# base_url = "http://192.0.2.10:4000/v1"   # optional override

[comprehension]
turn_gap_s = 1.5           # silence (seconds) that closes the other person's turn
context_pairs = 4          # how many recent turns to feed as context
include_suggestions = true # show optional reply suggestions
max_tokens = 300           # cap on the model's card response
# role_hint = "1:1 with my manager"   # optional, tailors the decode

Setting	Default	What it does
`provider.preset`	`llm-router`	Which LLM backend to use (see Providers).
`provider.model`	—	Model id as the provider expects it.
`provider.api_key`	`""`	Required for cloud presets; leave empty for local.
`provider.base_url`	preset default	Override the preset's endpoint (e.g. a remote llm-router).
`comprehension.turn_gap_s`	`1.5`	Silence gap that ends the other person's turn.
`comprehension.context_pairs`	`4`	Recent turns included as context for each card.
`comprehension.include_suggestions`	`true`	Whether cards include optional reply suggestions.
`comprehension.max_tokens`	`300`	Cap on the model's response length.
`comprehension.role_hint`	—	Optional hint about your role/relationship to tailor decoding.

With the real-llm feature, provider settings can also come from the environment: INTELLEGO_LLM_PRESET, INTELLEGO_LLM_MODEL, INTELLEGO_LLM_API_KEY, INTELLEGO_LLM_BASE_URL, INTELLEGO_LLM_TIMEOUT_MS.

Providers

The language model is configurable and local-first by default. All four presets speak the OpenAI-compatible chat API — only the endpoint, model, and key differ. Speech-to-text is always local.

Preset	Locality	Default endpoint	API key
`llm-router` (default)	Local	`http://localhost:4000/v1`	No
`ollama`	Local	`http://localhost:11434/v1`	No
`openai`	Cloud	`https://api.openai.com/v1`	Yes
`grok`	Cloud	`https://api.x.ai/v1`	Yes

Cloud presets won't start without a non-empty api_key. Local presets need no key. Use base_url to point a local preset at a remote endpoint.

Privacy

Local-first — speech-to-text runs on your machine, and the default LLM is local too. Cloud models are strictly opt-in.
Ephemeral — audio is decoded in the moment. Nothing is written to disk unless you explicitly enable saving.
Only the other party — intellego listens to the call audio reaching your device. It doesn't record you, and there's no speaker diarization.

How it works

The other party's call audio flows through a small, layered pipeline:

call audio (system loopback)
  → downmix + resample to 16 kHz
  → voice-activity detection (Silero) + utterance chunking
  → transcription (whisper.cpp)
  → turn assembly (closed on a silence gap)
  → language model → comprehension card
  → shown in the app

A turn closes when a configurable silence gap (default 1.5 s) follows the speech. Card generation runs on a bounded worker, so a slow model never stalls the pipeline — under sustained load the oldest pending turn is dropped and the most recent is always kept.

Troubleshooting

No card appears

Check that call audio is actually reaching your device's system output, and that your configured provider is running (for local presets, that the endpoint in the Providers table is reachable). With a mock build, cards come from bundled sample audio, not your live call.

"Model not found" / STT errors

The real-stt build needs ggml-base.en.bin and silero_vad.onnx in intellego-audio/models/ (or INTELLEGO_MODELS_DIR). A missing model reports a session error.

Authentication failed

Cloud presets (openai, grok) require a valid api_key. Local presets should have an empty key.

Cards are blank or partial

intellego leaves a facet blank when the model doesn't return it — this is expected. If every card is blank, the model may not be following the JSON format; try a different model or a provider that supports JSON responses.