TalkBridge — Product Dossier

01 The brief The problem worth solving

Every translation tool opens by asking the one question a speaker cannot answer.

What language are you about to speak? In a real bilingual conversation the answer changes sentence by sentence. People code-switch mid-thought: a Hindi speaker drops English nouns into a Hindi sentence, a Tamil speaker answers an English question in Tamil.

Asking each person to reach for a dropdown before every utterance is not a small friction. It is the reason these tools are abandoned after the first minute. Removing the question sounds like a product decision; it is actually the constraint that determines the architecture, because streaming source-language detection across Indian languages is a capability very few services offer at all.

01

The dropdown tax

Declaring your language before each sentence is the interaction that kills the product. Removing it means the source language must be resolved from the audio, every single turn, with no hint from the interface.

02

A silence you cannot explain

If the server cannot honour a language, quietly falling back to English is indistinguishable — from the speaker's side — from translation being broken. Every degraded state has to name itself instead.

03

The cost of a third person

A room of four could mean translating each utterance once per listener. It doesn't: one pass per distinct language, all dispatched together, so the last person waits for the slowest translation rather than the sum of them.

02 The product Built, not imagined

Built, not imagined.

Everything below is a photograph of the running application, taken from the deployed build. No mock-ups, no renderings, no interface that exists only on this page.

A room, not a translator

A name, a code, and how many people.

No install, no account, no sign-in. You type a room code and how big the room is — a pair, three, or four — and the server hands you a free place. You never choose a slot letter, and four people pressing Join in the same instant get four different places.

Server-side place assignment

The registry picks a free place while holding the lock it already had, so "is it free" and "take it" cannot be separated by another client.

The TalkBridge lobby: a room code field reading demo, a party size selector with 2, 3 and 4, a name field, a Join conversation button, and a Server connected indicator. — Lobby · 1440×900Captured live, 21 Sep 2026

A connected TalkBridge station: an empty conversation panel explaining that nobody else is here yet, and a side rail with the microphone control, the five-stage pipeline track, and the room roster. — Station · empty roomConnected to the tunnel, waiting for a second person

The conversation is the workspace

One panel for the talking, one rail for the machinery.

The transcript takes the room; the controls sit beside it. An empty room explains itself and names the code to share. The only language control anywhere on the page is translate anything into — what you read and hear. There is no control that sets what you are about to say, because there is no such setting.

One design system

Every colour resolves to a token; a check on every run proves no component invented one.

Invitations

Send the room, not the instructions.

A room code used to live only in the browser's storage, so a shared link dropped the recipient into their last room rather than yours — silently. Now the room travels in the link, and an invitation can be emailed from inside the room. The address is checked before anything is sent, and nothing about the conversation is stored to send it.

Verified end to end

A browser seeded with someone else's old room opened an invite link and landed in the inviter's room.

The invite panel inside a TalkBridge station: a copyable invite link, a Send it to email field, Close and Send invite buttons, and a note reading they get a link straight into this room, nothing else is stored or shared. — Invite · in-roomCaptured live, 21 Sep 2026

On a phone

The microphone is where your thumb is.

Not a shrunken desktop. Setup collapses to one card rather than a page of them, and on a station the microphone is on screen without scrolling for it — because a control you have to hunt for mid-sentence costs the sentence.

Measured, not eyeballed

At 390×844 the microphone occupies y=580–652 with 0 px of horizontal overflow.

03 Capabilities What the beta can actually do

What the beta can actually do.

Six capabilities, each one closed by a test that has been run against the deployment rather than a developer machine. The evidence for each is in the build ledger below.

01

Detection

The language is resolved from the audio on the final transcript, named on every delivered turn, and a language the server cannot honour says so on the notice channel instead of quietly becoming English.

Proven — detected and translated in one fused call

02

Fan-out

One utterance is translated once per distinct language in the room and delivered to everyone reading it. Two listeners on the same language share one pass and one turn identifier; the passes for different languages run together.

Proven — 3 languages at 2365 / 2813 / 2658 ms

03

Rooms

Capacity is fixed by the server when the room is created, reported back to every page, and cannot be got round by asking for a particular place. The person who does not fit is told the size rather than displacing anyone.

Proven — 5 rounds × 4 simultaneous joins, no collision

04

Voice

Synthesis returns 24 kHz audio with a loudness cutoff, because these are conversational audio models: left alone they answer the sentence instead of reading it, and pad two seconds of speech with minutes of silence. Both are handled, per language.

Proven — round-tripped exact in Telugu, Hindi, Tamil

05

Record

The whole conversation downloads as a text file — every turn, who spoke, the language pair, what they said and what the others heard. It is assembled in the browser from the turns already on screen; nothing is uploaded, because the server keeps no history to fetch.

Implemented — both halves of every turn, nothing uploaded

06

The seam

The browser speaks the tunnel's own message types and nothing else. It holds no provider key, no provider endpoint, and no branch on which vendor is behind an engine — what a control can do arrives in a catalogue from the server.

Proven — bundle scanned: 0 keys, 0 endpoints, 0 vendor ids

04 System Under the hood

Under the hood.

A working system, not a prototype slide. Audio flows down in one direction, is understood in the middle, and comes back as speech in somebody else's language. Nine components; hover or focus any box for what it owns.

The nine components and what each one owns
Component	What it owns	Where it lives
pages	The lobby, the four stations, names, settings, invitations, the transcript	`talkbridge/src/app`
capture	Microphone capture, resampling, the half-duplex gate, playback scheduling	`talkbridge/src/lib`
tunnel	Rooms, sockets, per-speaker settings, the peer broadcast	`pipecat-server/app/server.py`
vad	Cutting a continuous stream into utterances without losing the first word	`pipecat-server/app/rooms.py`
stt	Transcription and language detection, fused with translation by default	`pipecat-server/app/processors.py`
translate	Rendering the utterance into the listener's language	`pipecat-server/app/processors.py`
tts	Speech synthesis, and the cutoff that stops minutes of padded silence	`pipecat-server/app`
deploy	The two hosting environments, the address that joins them, and who may use it	`render.yaml`, `Dockerfile`
verify	The suite, and the corpus it runs against	`*/scripts`

Why a server in the middle at all

The browser could call a model provider directly, but that ships the account key to every client. One server hop keeps every credential server-side, and it is checked rather than asserted: every deployed asset is scanned for key prefixes on each release.

Two doors, two mechanisms

The browser rule that guards the REST routes never sees a WebSocket upgrade, so the socket applies the same origin list itself before it accepts a connection. The socket is the door that spends the key, and for a while only the cheaper one was locked.

05 The build ledger Requirement vs. reality

What we said we'd build. What actually exists.

Every requirement, against its real state. Partial means the capability is implemented but its test has not been run. Roadmap means it is not built. Nothing is marked complete on the strength of intent, and the notes name the run that closed each row.

Ledger derived from the project's task database, 21 Sep 2026

ManifestTalkBridge · Beta / 2026

Requirement	Implementation	Status
Nobody selects the language they speak	Detected from the audio on every utterance. No control anywhere sets a source language.The only language control on the page is "translate anything into"	Built
Two to four people, each on their own device	Four stations plus an auto-placed lobby; the server hands out places under its own lock.Five rounds of four simultaneous joins → four distinct places every round; the fifth refused	Built
Everyone hears everyone, each in their own language	One pass per distinct language, dispatched concurrently.One Hindi utterance → three listeners, three languages, audio on each, at 2365 / 2813 / 2658 ms	Built
Listeners sharing a language cost one pass	Grouped by target language before translation.Two listeners reading English share one turn id and identical text; the third receives Tamil	Built
Conversational latency, both directions	A 3.5 s budget, measured on the deployment rather than a laptop.English → Indic ×4: 2186 / 2268 / 2761 / 2561 ms. Indic → English: 1639 ms	Built
A long answer starts playing before it is finished	Sentence-level pipelining; the pieces share one turn and read as one entry.Three pieces at +1820 / +3275 / +4925 ms — the opening arrived 3105 ms before the turn finished	Built
No provider key reaches the browser	Every credential server-side; the client assets are scanned each release.8 deployed chunks (532 KB) plus the station document → 0 matches	Built
The browser knows nothing about which vendor is in use	A capability catalogue from the server, not a vendor id the page recognises.0 provider endpoints and 0 vendor-id comparisons in the deployed bundle	Built
Only the deployed pages may use the service	Two mechanisms: the origin list on the REST routes, and the same list applied by the socket before accept().A foreign origin refused before accept(); a client sending no origin still served	Built
A room holds only as many people as it was opened for	Capacity fixed server-side at creation, reported to every page, and not negotiable by asking for a place.The fourth into a room of three and the third into a pair were both refused, with the size named	Built
A hostile name cannot reach another screen	Names sanitised on the server before they are broadcast.A 71-character name containing ESC, BEL and NUL stored as 32 characters, all printable	Built
Invite someone without explaining the room code	The room travels in the link; an invitation can be emailed from inside the room, address checked first.Sent through the live interface 16 Sep 2026; a browser holding a different room still landed in the inviter's	Built
Survives a long silence mid-conversation	A translation tunnel is idle by definition whenever nobody is talking.300 seconds of streamed silence, both sockets open, then a delivered translation	Built
Synthesis reads the text rather than answering it	Checked by round trip — the spoken audio is transcribed back and compared with the text it was given.Telugu, Hindi and Tamil each returned the text exactly	Built
The opening word is never clipped	An 800 ms pre-roll buffer runs behind the speaker, because the voice detector spends about 160 ms unsure before it commits.Not proven. A WAV streamed from its first sample gives the buffer nothing to hold — this needs two words spoken into a real microphone	Partial
Translated audio plays without clicks or drift	Chunks are scheduled rather than played on arrival.Not proven. A multi-chunk turn has to be judged by ear in a real browser	Partial
One conversation on two real devices	Fifteen browser checks drive Chromium against the deployed pages.Not proven. No script catches stale browser state, autoplay policy and echo together — that needs two people and two machines	Partial
The first turn is as fast as the rest	The server makes its first call to the translation provider at start-up instead of leaving it to the first speaker.Cut the opening turn from 5740 ms to 3063 ms — but measured after a fresh deploy, not after an instance had genuinely slept	Partial
Accuracy figures you can quote	A benchmark harness with error rates, detection accuracy and cost per utterance exists.Its corpus is synthesised speech and tone placeholders by its own README, so no accuracy number drawn from it means anything yet	Roadmap
No cold start, ever	The tunnel is a managed container with a hostname that survives a restart, kept awake by a ten-minute health ping.On the free tier an instance still sleeps after about 15 minutes idle and takes 30–60 s to wake. A paid instance removes this; it is not bought	Roadmap
Accounts and authentication	None. Anyone with a room code can join it.Deliberate for a beta with no stored history. It has to exist before this carries anything sensitive	Roadmap

14Built

4Partial

3Roadmap

61Leaves in the task tree

5Ticked without a run

06 Walkthrough Follow the product

Follow the product.

Four screens, in the order a person meets them. Every one is the deployed build; the last is a frame from a recorded session you can watch in full.

Watch the recorded session

01

Enter

A room code, how many people, and a name. The lobby asks the tunnel which places are free and takes one — you never choose a slot letter.

Verified at 1440 and 390 px, 0 px horizontal overflow
02

Invite

From inside the room, copy the link or send it by email. Opening it drops that person into your room, even if their browser remembers a different one.

Live endpoint — a malformed address is refused before any mail is attempted
03

Speak

You set only what you read and hear. Press the microphone and talk normally; the stream is cut into utterances as you speak, and the five-stage track shows where the current turn has got to.

Listen · hear · translate · voice · deliver
04

Heard

Everyone gets the turn in their own language — spoken, and written with the original underneath. Three people, two languages, one utterance each way. The whole conversation downloads as text.

A real session — room clinicpl, Hindi arriving as Telugu

Captured from the beta build The activity timings visible in the recording are genuine — the microphone is fed a real clip and the tunnel does the real work.

07 Roadmap Where the system goes next

Where the system goes next.

Three stages, and no commitments that are not already designed. Anything that would need a protocol decision is named as one rather than drawn as a feature.

Now

Live in the deployed build

Rooms of fourTwo, three or four people, capacity fixed by the server, places handed out without collision.
Language fan-outOne pass per distinct language, dispatched concurrently, so the last listener waits for the slowest single translation.
Sentence pipeliningA long turn starts playing before its last sentence is translated, and still reads as one entry.
InvitationsThe room travels in the link; an email invite goes out from inside the room.
Origin lockOnly the deployed pages may open a socket or read the REST routes.

A corpus of real speechThe benchmark harness is built and runs; its recordings are synthesised, which flatters whichever vendor produced them. Real speakers are what make an accuracy figure quotable.
Four checks only a human closesTwo words into a real microphone with room noise; a multi-chunk turn judged by ear; two people on two devices; a first turn after an instance has genuinely slept.
An instance that does not sleepA paid container removes the 30–60 second wake and the ten-minute keep-warm ping along with it.

Later

Planned — needs a decision first

AuthenticationThere is none today, deliberately: no accounts and no stored history. It has to exist before this carries anything sensitive.
More languagesSix are verified end to end. The limit is synthesis, not transcription — a language with no voice gets you a translation nobody can hear, so the catalogue only lists what can be spoken.
Typing instead of speakingNot built and not faked. The tunnel protocol carries audio, settings, control and ping; a text turn needs both ends to carry one first.

08 Deployment From repository to running system

From repository to running system.

Two halves that cannot be merged: static pages on a serverless host, and a process that holds a socket open for the length of a conversation. The same codebase runs both lanes — the difference is environment variables, not code.

Lane 01 · on your hardware

Your server, your key.

The tunnel runs on a machine you control. Audio from every speaker passes only through your process, and the provider key never leaves it.

01CODEone Python process, one port
02RUNlocal tunnel on :7860, pages on :3000
03REACHa second device over a tunnel you run
04OUTmodel calls are the only outbound traffic

Lane 02 · cloud twin — what this page points at

Nothing to install.

The identical server as a managed container, with the pages on a static host in front. Up around the clock, reachable from any browser, no account for the people talking.

01CODEone repository, two deploy targets
02BUILDthe tunnel address is inlined into the pages at build time
03HOSTVercel serves the pages · Render runs the container
04GUARDorigin list on the routes, and again on the socket
05PIPELINEevery credential stays on the server

Status at last check — 21 Sep 2026

The pages answer on their own hostname, the tunnel is reachable over the public internet, and a real turn was run end to end against the deployment on the date above: Hindi in, translated text and 80 KB of spoken audio back. The room, the socket and the whole pipeline are live.

What is never in a client

No key, no provider endpoint, no vendor identity. The browser speaks the tunnel's own message types; anything it needs to know about what an engine can do arrives as a capability in the catalogue, never as a name it recognises.

09 The proof

Don't take the documentation's word for it.

Open a room, send the link to somebody, and speak. Two browsers and two languages is the whole setup — there is no account to make and nothing to install.

Launch live beta Read documentation

Live beta · pages reachable · a real turn verified against the deployment, 21 Sep 2026

A real session, recorded end to end

Nothing is mocked. The microphone is fed an actual clip and the tunnel does the real work, so the timings on screen are genuine. The capture is silent — the translated audio plays on the listeners' devices, not this one.

Nobody picks the language they are about to speak.