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

At a glance

Works with
Universal · cross-platformOpenAI API · Claude API
You'll need
Go toolchainONNX Runtime (only for turn-taking/VAD, loaded at runtime)RNNoise (optional noise reduction)STT/LLM/TTS provider API keysDocker (optional deployment)Shell / CLINetwork accessLocal filesystem
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.

  1. 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).
  2. Teams that must serve many concurrent voice sessions from one service and want to replace a GIL-bound Python Pipecat deployment.
  3. Developers who want a uniform abstraction over STT/LLM/TTS vendors and to swap Deepgram, OpenAI, ElevenLabs and others behind a small interface.
  4. Teams needing phone agents: inbound/outbound calls over Twilio Media Streams, with the idle watchdog re-engaging or hanging up on silent callers.
  5. Teams preferring single-model speech-to-speech agents on OpenAI Realtime, Gemini Live or AWS Nova Sonic.
  6. 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_KEY OPENAI_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/jargo

To 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-thing

The 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-bot

You 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?

Pros
  • Pure Go with a cgo-free default build: CGO_ENABLED=0 go build yields 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.
Limitations
  • 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?

FollowAgents source review · FARS-2.1
Some gaps
74/ 100 5-point scale 3.7 / 5
Trust 18/29
Reliability 12/14
Adaptability 15/18
Convention 15/18
Effectiveness 9/13
Verifiability 5/8
Why each dimension lost points
Trust18 / 29 · 3.1/5

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).

Reliability12 / 14 · 4.3/5

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).

Adaptability15 / 18 · 4.2/5

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).

Convention15 / 18 · 4.2/5

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).

Effectiveness9 / 13 · 3.5/5

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).

Verifiability5 / 8 · 3.1/5

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).

Risks and how to mitigate them
  • 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.
Evidence confidence: Low Reviewed Nov 21, 2026 Reviewed revision 6061ddefc64c
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/jargo.svg)](https://followagents.com/en/agents/jargo)
<a href="https://followagents.com/en/agents/jargo"><img src="https://followagents.com/badge/jargo.svg" alt="FARS review"></a>

FAQ

Is jargo open source?
Yes. The source code is on GitHub (gojargo/jargo) under the BSD-2-Clause licence.
Is jargo safe to use?
FollowAgents' FARS review (Nov 21, 2026) scored jargo 18/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is jargo still maintained?
Yes. The latest commit on GitHub is from 2026-11-20, within the last 30 days.
Who makes jargo?
jargo is published on GitHub by the account gojargo. FollowAgents has not verified which person or company is behind that account.
What is jargo's official website?
The project's GitHub repository lists https://gojargo.dev/ as its website. That link is set by the repository owner; the source code itself is on GitHub (gojargo/jargo).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts