jargo
A WebRTC-native, audio-first conversational-AI framework for Go: streaming STT→LLM→TTS with turn-taking and barge-in, shipped as one static binary.
- Source repo
- gojargo/jargo
- Stars
- ★ 112
- Last updated
- 2d ago
- License
- BSD-2-Clause
- Primary language
- Go
- FA score
- 74/100 · Some gaps
At a glance
- Works with
- Universal · cross-platformOpenAI API · Claude API
- You'll need
- Typical use
- A Go backend team building a real-time browser voice assistant with turn-taking and barge-in (browser connects over WebRTC; see the 06-voice-agent example).
- Main limitation
- The full turn-taking and barge-in experience depends on a run-time-loaded ONNX Runtime shared library; without it the bot degrades to STT endpointing and loses barge-in.
- Website
- gojargo.dev ↗ set on GitHub
- Maintenance
- Commits in the last 30 dayslast commit 2026-11-20
- Source review
- 74/100 · Some gaps
What does this agent do, and when should you use it?
jargo (gojargo/jargo) is a Go port of Pipecat — a real-time voice-agent framework that is WebRTC-native and audio-first. It models a voice bot as a streaming frame pipeline: audio arrives over a WebRTC, WebSocket, LiveKit or local-audio transport and flows through STT, LLM and TTS processors, with aggregators providing turn-taking and barge-in (interruptions are just frames). The engine is built on Frames and Processors, every service is pluggable behind a small interface, and it supports both the classic STT→LLM→TTS pipeline and single-model speech-to-speech agents (OpenAI Realtime, Gemini Live, AWS Nova Sonic). The default build is cgo-free, and the Silero VAD and Smart Turn v3 ONNX models are embedded in the binary, with the ONNX Runtime shared library loaded only at run time via purego. Official benchmarks show one jargo process serving 1,000 concurrent sessions on 3 CPUs at 124 MiB memory and 96k frames/s, well ahead of Pipecat on the same hardware. It suits developers who want to build their own real-time voice bots in Go.
jargo receives audio via rtc.NewTransport (Pion-based WebRTC, or WebSocket/LiveKit/local audio) and runs it through a processor pipeline with pipeline.NewWorker: chat.NewSTT streams transcription; the User/Assistant aggregators from aggregators.New, backed by Silero VAD and Smart Turn v3 (local ONNX), decide when the user finished and enable barge-in; chat.NewLLM generates the reply; chat.NewTTS synthesizes speech that goes back out through the transport, with Opus encode/decode and resampling implemented in pure Go. Every STT/LLM/TTS is a pluggable Config + constructor covering dozens of providers — Deepgram, AssemblyAI, Whisper, Anthropic, OpenAI, Gemini, Groq, ElevenLabs, Cartesia and more — plus mem0 memory and optional Twilio Media Streams telephony with a user-idle watchdog. The examples/getting-started series builds up step by step from one spoken sentence to a full tool-using voice agent (06-voice-agent), examples/voice/ wires each provider explicitly, and the echo example runs with no API keys.
- A Go backend team building a real-time browser voice assistant with turn-taking and barge-in (browser connects over WebRTC; see the 06-voice-agent example).
- Teams that must serve many concurrent voice sessions from one service and want to replace a GIL-bound Python Pipecat deployment.
- Developers who want a uniform abstraction over STT/LLM/TTS vendors and to swap Deepgram, OpenAI, ElevenLabs and others behind a small interface.
- Teams needing phone agents: inbound/outbound calls over Twilio Media Streams, with the idle watchdog re-engaging or hanging up on silent callers.
- Teams preferring single-model speech-to-speech agents on OpenAI Realtime, Gemini Live or AWS Nova Sonic.
- Ops teams deploying voice bots in distroless containers using the gojargo/jargo base image that bundles the ONNX Runtime.
Key setup facts
Pulled from the install and usage notes below. The project README has the current values.
- Install / run
docker run --rm -p 8080:8080 -e OPENAI_API_KEY=$OPENAI_API_KEY my-bot
- Environment variables
CARTESIA_API_KEYOPENAI_API_KEY- Install notes cover
- Docker
How do you install or deploy this agent?
Install as a Go dependency (no cgo — no C toolchain or system packages needed to build):
go get github.com/gojargo/jargoTo run a voice bot you need one shared library, ONNX Runtime, and only for turn-taking (get it with make deps-onnx or a Microsoft onnxruntime release; RNNoise is optional noise reduction). Both are loaded at run time through purego — point jargo at them with JARGO_ONNXRUNTIME_LIB and JARGO_RNNOISE_LIB, or place them on the loader's default search path. For Docker, build on the gojargo/jargo-build base image and ship on the distroless gojargo/jargo runtime image (which bundles the ONNX Runtime).
How do you use this agent?
The heart of a minimal STT → LLM → TTS voice agent:
stt := chat.NewSTT(chat.STTConfig{APIKey: key, SampleRate: opus.SampleRate})
llm := chat.NewLLM(chat.LLMConfig{APIKey: key})
tts := chat.NewTTS(chat.TTSConfig{APIKey: key})
t := rtc.NewTransport(conn, transport.DefaultParams())
agg := aggregators.New(frames.NewLLMContext("You are a helpful voice assistant."))
task := pipeline.NewWorker(pipeline.New(
t.Input(), stt, agg.User(), llm, tts, t.Output(), agg.Assistant(),
), pipeline.WorkerConfig{})
task.Run(ctx)Try the built-in examples immediately (open http://localhost:7860 in a browser):
CARTESIA_API_KEY=... go run ./examples/getting-started/01-say-one-thingThe complete voice agent lives in examples/getting-started/06-voice-agent; per-provider examples run with commands like go run ./examples/voice/voice-deepgram-flux. Docker deployment:
docker run --rm -p 8080:8080 -e OPENAI_API_KEY=$OPENAI_API_KEY my-botYou need API keys for whichever STT/LLM/TTS providers you pick. Full documentation is at gojargo.dev; the API reference is pkg.go.dev/github.com/gojargo/jargo.
What are this agent's strengths and limitations?
- Pure Go with a cgo-free default build:
CGO_ENABLED=0 go buildyields a single static binary with simple deployment, low memory and fast startup. - Silero VAD and Smart Turn v3 ONNX models are embedded in the binary, giving local turn detection and barge-in without a separate model service.
- Official benchmarks show far lower framework overhead than Pipecat: at 1,000 sessions, 124 MiB vs 357 MiB memory, 96k vs 10.8k frames/s throughput, 0.12 ms vs 1.08 ms per-session startup.
- A very wide, pluggable provider matrix: STT, LLM, TTS, speech-to-speech and memory are separate categories, each a small Config plus constructor.
- The full turn-taking and barge-in experience depends on a run-time-loaded ONNX Runtime shared library; without it the bot degrades to STT endpointing and loses barge-in.
- As an independent port of Pipecat, jargo is not affiliated with or endorsed by Daily; the upstream Pipecat ecosystem and community support do not carry over.
- Speech-to-speech and most STT/TTS providers require paid cloud API keys; real cost is dominated by per-use provider billing.
- It is a framework for building voice bots, not a finished product: you must write Go code and wire transports and providers to get a working bot.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| jargo This agent | 74 · Some gaps | — | ★ 112 | 2d ago | Go | OpenAI API · Claude API |
| Rapida Voice | 46 · Major gaps | Self-hosted serviceFree + model costs | ★ 760 | 14d ago | Go | OpenAI API · Claude API |
| Voice AI Learning Path | 68 · Some gaps | Library / SDKFree | ★ 342 | 24d ago | Astro | — |
| Stream Vision Agents | 57 · Major gaps | Library / SDKFree + model costs | ★ 8.2k | 1d ago | Go | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
Library packages read no env vars, validate explicit Config structs, and load native libraries only when needed — good least privilege (2); user confirmation mechanisms are essentially absent (e.g., Twilio outbound calls have no confirmation flow) (1); docs clearly state where audio/text flows (cloud providers) (2); sensitive data handling (audio/PII retention) has no dedicated guidance (1); govulncheck, gitleaks, Semgrep, pinned CI actions, signed releases with provenance attestations (3); no rollback mechanism shown (1); upstream Pipecat attribution preserved verbatim in LICENSE/NOTICE/README — exemplary (3).
README, AGENTS.md and docs agree on build, dependencies and fallback behavior (3); every runtime library has a documented degradation path (STT endpointing fallback, ErrLibraryNotAvailable) (3); error messages have concrete examples but are not systematically shown (2).
Clear audience (Go voice-agent developers) with a graded example series (3); capability boundaries partly stated (no ONNX loses barge-in, pre-1.0 API) but incomplete (2); framework not trigger-based, scored on interface explicitness (2); Docker, purego and cross-platform path documentation fit environments well (3).
Clean docs/ layout with a link-checking test (3); thorough install docs covering all runtime libraries (3); conventions defined but pre-1.0 API may change (2); rich examples, no FAQ (3); limitations stated but scattered (2); BSD-2 with upstream copyright intact (3); CHANGELOG/Conventional Commits mandated but CHANGELOG content unseen (2); SECURITY.md defines supported versions and private reporting, but maintainer identity and maturity are unknown (2).
Output usability assessed statically: the eval runner structure is clear (2); a Go port of Pipecat has clear differentiation; benchmark ratios are only meaningful within one job (2); docs honestly scope results to 'framework overhead only' — quantified but conditional cost/benefit (2).
Benchmark numbers point to a method doc (2); README/docs/CI corroborate build and dependency claims (2); the benchmark section separates facts from methodological caveats, but all claims remain self-reported and unverified by execution (2).
- This is a framework, not an autonomous agent: audio and text are streamed in real time to third-party cloud services (STT/LLM/TTS); deployment teams must assess data compliance and retention themselves.
- External effects such as Twilio outbound calls have no confirmation or authorization flow — implement this at the application layer.
- No guidance on sensitive data handling (recordings, PII); pre-1.0 with a public API that may break in any minor release.
- Benchmarks are self-reported and meaningful only within a single CI job; consult docs/benchmarks.md before quoting. Publisher identity is unverified.
- Without the ONNX Runtime the bot silently degrades to STT endpointing and loses barge-in — explicitly verify required libraries at deployment.
FAQ
Is jargo open source?
Is jargo safe to use?
Is jargo still maintained?
Who makes jargo?
What is jargo's official website?
Thanks — we use this to improve the page.