English | Tiếng Việt

Summo

Summo is a meeting recorder and notebook that runs on your own machine: it records or imports a meeting, transcribes it with speakers named, and keeps the result as a Markdown file you can open, grep, sync or delete yourself. Speech recognition and speaker attribution never leave the device; only summarisation and translation call out to a language model, and only if you have configured one.

Product site: summo.techainer.com.

The three rules

The expensive part of a meeting recorder is real-time transcription. Doing it locally removes the GPU bill entirely, which is what makes it possible to sell the hosted extras cheaply — and it means the recording of your meeting is a file on your disk rather than a row in someone's database. Three rules follow from that, and they decide most of the design:

1. Speech recognition and diarisation are always local. There is no cloud-ASR fallback.
2. Press record and it records — recording starts in under a second, with no dialog box in the way. Summaries run after the meeting ends, because that is when you want them.
3. Your data is ~/.summo/vault — Markdown files you can open in Obsidian, grep, back up or delete yourself. Same path on every platform, typeable from memory.

What works today

Usable end to end: record or import a recording, get a transcript with speakers named, an agent-drafted summary you approve, tasks on a board, questions answered from the vault with citations, live translation of whatever is playing, dubbing, notes, calendars, comments, a roster of agents you edit as files, and encrypted sync between machines through any folder you both can reach.

Not done: mobile is scaffolded and has never been compiled, and the hosted sync relay is not built — sync works today through any shared folder instead.

The numbers below are measured on this codebase, not estimated. Each is reproducible with the command shown; see docs/benchmarks.md and docs/translation.md for the full method and caveats.

Claim	Measured	Source
Vietnamese recognition accuracy	2.4 % WER, 1.7 % CER (gipformer-65M, Fleurs VI test set)	cargo run --release -p summo-bench --features asr -- asr
Live pipeline speed	RTF 0.107, roughly 9× faster than realtime (raw mic capture)	docs/benchmarks.md, end-to-end pipeline section — two short single-mic captures, not yet WER-scored
Voice activity detection	Silero v5, F1 0.940 (precision 0.925, recall 0.956)	cargo run --release -p summo-bench --features silero -- vad --sweep
Finding a meeting without an index	~30 ms across 1,000 meetings (8-thread scan), which is why there is no database	cargo run --release -p summo-bench -- vault --sizes 100,1000,5000
Translating a line	~244 ms/line, 8 threads, with the default 583 MB small100 model	cargo run -p summo-mt --features local,onnx --example compare

Install and run

One command, the way ollama is one command. The interface is compiled into the binary, so there is no web server to start and no directory of static files to keep in step.

./scripts/bundle.sh          # a tarball in dist/, ready to move to another machine
tar -xzf dist/summo-*.tar.gz && cd summo-* && ./summo serve

Or building from source, without packaging:

pnpm install && pnpm --filter @summo/web build       # the interface, once
cargo run -p summo-cli --features serve,models -- serve

That prints an address and opens it. First run has one decision in it: which speech model to download. Summo ranks what is available against your machine and says why — memory, measured real-time factor, licence — and you can disagree with it. Nothing is recorded until you press record.

summo serve --port 8710      # a fixed port, when something else wants to find it
summo serve --no-open        # a server, when there is no browser to open
summo import ~/Downloads/zoom-recording.mp4
summo mcp                    # the vault over MCP, for Claude Code or Cursor

There are two ways to build the release bundle: with speech recognition (the ONNX Runtime and sherpa-onnx libraries travel beside the binary), or with --no-models, which is smaller and browses a vault, imports, summarises and answers questions, but cannot transcribe.

Model catalogue

Models are not bundled with Summo. They are fetched at runtime from a registry of static JSON manifests, each carrying a licence, a sha256 per file and the numbers measured for it:

summo recommend --lang vi     # what would run here, and why
summo pull gipformer-65m      # 2.4 % WER on Fleurs VI, ~70 MB, MIT

The catalogue lives in Techainer/summo-registry (MIT, static JSON, forkable and mirrorable). A model resolves through SUMMO_REGISTRY → our CDN → the registry repository on GitHub → the URL inside the manifest, which points at whoever published the weights — permissive models are mirrored, gated and non-commercial ones point straight at their original host (for example the Hugging Face repositories named in each manifest's files[].url), so Summo is never the distributor of a licence it cannot redistribute under.

Verifying the privacy claim

Disconnect the machine from the network, then run ./summo serve and record a meeting. Recognition, voice-activity detection and speaker attribution keep working, because they never called out — there is no cloud-ASR fallback to fail over to. What you should not be able to do offline is get a summary or a translation from a remote model you configured, since that is the one deliberate exception to "nothing leaves the machine".

The rest of the promise is enforced in code, not only in this description — see SECURITY.md: the daemon binds 127.0.0.1 only, every route requires a token written to ~/.summo/engine.json, and a browser page cannot reach it unless the daemon was started with --dev, which no shipped build does.

Architecture

crates/
  summo-core      shared types: segments, events, paths, errors
  summo-models    Ollama-style model registry: manifests, resumable downloads, blob store, hw probe
  summo-vad       voice activity detection: pluggable backends and the segment gate that drives ASR
  summo-asr       decoding sessions: pseudo-streaming, hybrid refine, sherpa runtime
  summo-diar      speaker attribution: track priors, online clustering, refinement
  summo-vault     the Markdown vault: meetings as files you own
  summo-llm       summaries, translation and Q&A — the only part that leaves the machine
  summo-engine    the local daemon: capture, recognition and events over loopback
  summo-cli       `summo serve | setup | pull | import | ask | export | registry`
  summo-agent     the agent: aionrs core, Summo's own tools
  summo-mcp       the vault over MCP — tools, resources and prompts, on stdio or HTTP
  summo-sync      CRDT and end-to-end-encrypted multi-device sync
apps/
  web/            the application interface — React, compiled into the binary
  desktop/        the Tauri shell: window, tray, global shortcut
  mobile/         Tauri iOS/Android                          [scaffolded, never compiled]

summo-bench, summo-audio, summo-media, summo-calendar, summo-tts and summo-store cover measurement, capture, ffmpeg, calendars, dubbing and semantic search respectively — see crates/ for all seventeen.

Contributing

• CONTRIBUTING.md — how to run it, and every check CI runs so you can run them first
• CODE_OF_CONDUCT.md
• SECURITY.md — what the product promises, and where to report a hole in one
• docs/adr/ — the decisions that shaped this, and what would reopen each of them

Licence

AGPL-3.0-or-later. Models are fetched at runtime and keep their own licences; see NOTICE. The application itself is split from the hosted extras on purpose: this repository imports nothing from summo-cloud, the proprietary repository that runs the CDN, billing and the sync relay — delete it and Summo keeps recording, transcribing, installing models and exporting, and only sync stops.